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.61 by jsr166, Wed Jun 4 04:34:49 2014 UTC vs.
Revision 1.130 by jsr166, Sun Nov 15 17:21:44 2015 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.TimeoutException;
34 + import java.util.concurrent.TimeUnit;
35   import java.util.concurrent.atomic.AtomicInteger;
36 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
25 < import static java.util.concurrent.TimeUnit.SECONDS;
26 < import java.util.*;
27 < import java.util.function.Supplier;
28 < import java.util.function.Consumer;
36 > import java.util.concurrent.atomic.AtomicReference;
37   import java.util.function.BiConsumer;
30 – 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 44 | 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); }
# Line 57 | 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));
62 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
75 >        checkTimedGet(f, value);
76 >
77          try {
78              assertEquals(value, f.join());
79          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 75 | Line 89 | public class CompletableFutureTest exten
89          assertTrue(f.toString().contains("[Completed normally]"));
90      }
91  
92 <    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
93 <        try {
94 <            f.get(LONG_DELAY_MS, MILLISECONDS);
95 <            shouldThrow();
96 <        } catch (ExecutionException success) {
97 <            assertTrue(success.getCause() instanceof CFException);
98 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
99 <        try {
100 <            f.join();
101 <            shouldThrow();
102 <        } catch (CompletionException success) {
103 <            assertTrue(success.getCause() instanceof CFException);
104 <        }
105 <        try {
106 <            f.getNow(null);
107 <            shouldThrow();
108 <        } catch (CompletionException success) {
95 <            assertTrue(success.getCause() instanceof CFException);
92 >    /**
93 >     * Returns the "raw" internal exceptional completion of f,
94 >     * without any additional wrapping with CompletionException.
95 >     */
96 >    <U> Throwable exceptionalCompletion(CompletableFuture<U> f) {
97 >        // handle (and whenComplete) can distinguish between "direct"
98 >        // and "wrapped" exceptional completion
99 >        return f.handle((U u, Throwable t) -> t).join();
100 >    }
101 >
102 >    void checkCompletedExceptionally(CompletableFuture<?> f,
103 >                                     boolean wrapped,
104 >                                     Consumer<Throwable> checker) {
105 >        Throwable cause = exceptionalCompletion(f);
106 >        if (wrapped) {
107 >            assertTrue(cause instanceof CompletionException);
108 >            cause = cause.getCause();
109          }
110 <        try {
98 <            f.get();
99 <            shouldThrow();
100 <        } catch (ExecutionException success) {
101 <            assertTrue(success.getCause() instanceof CFException);
102 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
103 <        assertTrue(f.isDone());
104 <        assertFalse(f.isCancelled());
105 <        assertTrue(f.toString().contains("[Completed exceptionally]"));
106 <    }
110 >        checker.accept(cause);
111  
112 <    void checkCompletedWithWrappedCFException(CompletableFuture<?> f,
109 <                                              CFException ex) {
112 >        long startTime = System.nanoTime();
113          try {
114              f.get(LONG_DELAY_MS, MILLISECONDS);
115              shouldThrow();
116          } catch (ExecutionException success) {
117 <            assertSame(ex, success.getCause());
117 >            assertSame(cause, success.getCause());
118          } catch (Throwable fail) { threadUnexpectedException(fail); }
119 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
120 +
121          try {
122              f.join();
123              shouldThrow();
124          } catch (CompletionException success) {
125 <            assertSame(ex, success.getCause());
126 <        }
125 >            assertSame(cause, success.getCause());
126 >        } catch (Throwable fail) { threadUnexpectedException(fail); }
127 >
128          try {
129              f.getNow(null);
130              shouldThrow();
131          } catch (CompletionException success) {
132 <            assertSame(ex, success.getCause());
133 <        }
132 >            assertSame(cause, success.getCause());
133 >        } catch (Throwable fail) { threadUnexpectedException(fail); }
134 >
135          try {
136              f.get();
137              shouldThrow();
138          } catch (ExecutionException success) {
139 <            assertSame(ex, success.getCause());
139 >            assertSame(cause, success.getCause());
140          } catch (Throwable fail) { threadUnexpectedException(fail); }
141 <        assertTrue(f.isDone());
141 >
142          assertFalse(f.isCancelled());
143 +        assertTrue(f.isDone());
144 +        assertTrue(f.isCompletedExceptionally());
145          assertTrue(f.toString().contains("[Completed exceptionally]"));
146      }
147  
148 +    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
149 +        checkCompletedExceptionally(f, true,
150 +            (t) -> assertTrue(t instanceof CFException));
151 +    }
152 +
153 +    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
154 +        checkCompletedExceptionally(f, true,
155 +            (t) -> assertTrue(t instanceof CancellationException));
156 +    }
157 +
158 +    void checkCompletedWithTimeoutException(CompletableFuture<?> f) {
159 +        checkCompletedExceptionally(f, false,
160 +            (t) -> assertTrue(t instanceof TimeoutException));
161 +    }
162 +
163 +    void checkCompletedWithWrappedException(CompletableFuture<?> f,
164 +                                            Throwable ex) {
165 +        checkCompletedExceptionally(f, true, (t) -> assertSame(t, ex));
166 +    }
167 +
168 +    void checkCompletedExceptionally(CompletableFuture<?> f, Throwable ex) {
169 +        checkCompletedExceptionally(f, false, (t) -> assertSame(t, ex));
170 +    }
171 +
172      void checkCancelled(CompletableFuture<?> f) {
173 +        long startTime = System.nanoTime();
174          try {
175              f.get(LONG_DELAY_MS, MILLISECONDS);
176              shouldThrow();
177          } catch (CancellationException success) {
178          } catch (Throwable fail) { threadUnexpectedException(fail); }
179 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
180 +
181          try {
182              f.join();
183              shouldThrow();
# Line 155 | Line 191 | public class CompletableFutureTest exten
191              shouldThrow();
192          } catch (CancellationException success) {
193          } catch (Throwable fail) { threadUnexpectedException(fail); }
158 –        assertTrue(f.isDone());
159 –        assertTrue(f.isCompletedExceptionally());
160 –        assertTrue(f.isCancelled());
161 –        assertTrue(f.toString().contains("[Completed exceptionally]"));
162 –    }
194  
195 <    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
196 <        try {
166 <            f.get(LONG_DELAY_MS, MILLISECONDS);
167 <            shouldThrow();
168 <        } catch (ExecutionException success) {
169 <            assertTrue(success.getCause() instanceof CancellationException);
170 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
171 <        try {
172 <            f.join();
173 <            shouldThrow();
174 <        } catch (CompletionException success) {
175 <            assertTrue(success.getCause() instanceof CancellationException);
176 <        }
177 <        try {
178 <            f.getNow(null);
179 <            shouldThrow();
180 <        } catch (CompletionException success) {
181 <            assertTrue(success.getCause() instanceof CancellationException);
182 <        }
183 <        try {
184 <            f.get();
185 <            shouldThrow();
186 <        } catch (ExecutionException success) {
187 <            assertTrue(success.getCause() instanceof CancellationException);
188 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
195 >        assertTrue(exceptionalCompletion(f) instanceof CancellationException);
196 >
197          assertTrue(f.isDone());
190 –        assertFalse(f.isCancelled());
198          assertTrue(f.isCompletedExceptionally());
199 +        assertTrue(f.isCancelled());
200          assertTrue(f.toString().contains("[Completed exceptionally]"));
201      }
202  
# Line 206 | Line 214 | public class CompletableFutureTest exten
214       * isCancelled, join, get, and getNow
215       */
216      public void testComplete() {
217 +        for (Integer v1 : new Integer[] { 1, null })
218 +    {
219          CompletableFuture<Integer> f = new CompletableFuture<>();
220          checkIncomplete(f);
221 <        f.complete(one);
222 <        checkCompletedNormally(f, one);
223 <    }
221 >        assertTrue(f.complete(v1));
222 >        assertFalse(f.complete(v1));
223 >        checkCompletedNormally(f, v1);
224 >    }}
225  
226      /**
227       * completeExceptionally completes exceptionally, as indicated by
# Line 218 | Line 229 | public class CompletableFutureTest exten
229       */
230      public void testCompleteExceptionally() {
231          CompletableFuture<Integer> f = new CompletableFuture<>();
232 +        CFException ex = new CFException();
233          checkIncomplete(f);
234 <        f.completeExceptionally(new CFException());
235 <        checkCompletedWithWrappedCFException(f);
234 >        f.completeExceptionally(ex);
235 >        checkCompletedExceptionally(f, ex);
236      }
237  
238      /**
# Line 228 | Line 240 | public class CompletableFutureTest exten
240       * methods isDone, isCancelled, join, get, and getNow
241       */
242      public void testCancel() {
243 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
244 +    {
245          CompletableFuture<Integer> f = new CompletableFuture<>();
246          checkIncomplete(f);
247 <        assertTrue(f.cancel(true));
247 >        assertTrue(f.cancel(mayInterruptIfRunning));
248 >        assertTrue(f.cancel(mayInterruptIfRunning));
249 >        assertTrue(f.cancel(!mayInterruptIfRunning));
250          checkCancelled(f);
251 <    }
251 >    }}
252  
253      /**
254       * obtrudeValue forces completion with given value
# Line 240 | Line 256 | public class CompletableFutureTest exten
256      public void testObtrudeValue() {
257          CompletableFuture<Integer> f = new CompletableFuture<>();
258          checkIncomplete(f);
259 <        f.complete(one);
259 >        assertTrue(f.complete(one));
260          checkCompletedNormally(f, one);
261          f.obtrudeValue(three);
262          checkCompletedNormally(f, three);
# Line 261 | Line 277 | public class CompletableFutureTest exten
277       * obtrudeException forces completion with given exception
278       */
279      public void testObtrudeException() {
280 <        CompletableFuture<Integer> f = new CompletableFuture<>();
281 <        checkIncomplete(f);
282 <        f.complete(one);
283 <        checkCompletedNormally(f, one);
284 <        f.obtrudeException(new CFException());
269 <        checkCompletedWithWrappedCFException(f);
280 >        for (Integer v1 : new Integer[] { 1, null })
281 >    {
282 >        CFException ex;
283 >        CompletableFuture<Integer> f;
284 >
285          f = new CompletableFuture<>();
286 <        f.obtrudeException(new CFException());
287 <        checkCompletedWithWrappedCFException(f);
286 >        assertTrue(f.complete(v1));
287 >        for (int i = 0; i < 2; i++) {
288 >            f.obtrudeException(ex = new CFException());
289 >            checkCompletedExceptionally(f, ex);
290 >        }
291 >
292 >        f = new CompletableFuture<>();
293 >        for (int i = 0; i < 2; i++) {
294 >            f.obtrudeException(ex = new CFException());
295 >            checkCompletedExceptionally(f, ex);
296 >        }
297 >
298          f = new CompletableFuture<>();
299 +        f.completeExceptionally(ex = new CFException());
300 +        f.obtrudeValue(v1);
301 +        checkCompletedNormally(f, v1);
302 +        f.obtrudeException(ex = new CFException());
303 +        checkCompletedExceptionally(f, ex);
304          f.completeExceptionally(new CFException());
305 <        f.obtrudeValue(four);
306 <        checkCompletedNormally(f, four);
307 <        f.obtrudeException(new CFException());
308 <        checkCompletedWithWrappedCFException(f);
279 <    }
305 >        checkCompletedExceptionally(f, ex);
306 >        assertFalse(f.complete(v1));
307 >        checkCompletedExceptionally(f, ex);
308 >    }}
309  
310      /**
311       * getNumberOfDependents returns number of dependent tasks
312       */
313      public void testGetNumberOfDependents() {
314 +        for (ExecutionMode m : ExecutionMode.values())
315 +        for (Integer v1 : new Integer[] { 1, null })
316 +    {
317          CompletableFuture<Integer> f = new CompletableFuture<>();
318          assertEquals(0, f.getNumberOfDependents());
319 <        CompletableFuture g = f.thenRun(new Noop(ExecutionMode.DEFAULT));
319 >        final CompletableFuture<Void> g = m.thenRun(f, new Noop(m));
320          assertEquals(1, f.getNumberOfDependents());
321          assertEquals(0, g.getNumberOfDependents());
322 <        CompletableFuture h = f.thenRun(new Noop(ExecutionMode.DEFAULT));
322 >        final CompletableFuture<Void> h = m.thenRun(f, new Noop(m));
323          assertEquals(2, f.getNumberOfDependents());
324 <        f.complete(1);
324 >        assertEquals(0, h.getNumberOfDependents());
325 >        assertTrue(f.complete(v1));
326          checkCompletedNormally(g, null);
327 +        checkCompletedNormally(h, null);
328          assertEquals(0, f.getNumberOfDependents());
329          assertEquals(0, g.getNumberOfDependents());
330 <    }
330 >        assertEquals(0, h.getNumberOfDependents());
331 >    }}
332  
333      /**
334       * toString indicates current completion state
# Line 304 | Line 339 | public class CompletableFutureTest exten
339          f = new CompletableFuture<String>();
340          assertTrue(f.toString().contains("[Not completed]"));
341  
342 <        f.complete("foo");
342 >        assertTrue(f.complete("foo"));
343          assertTrue(f.toString().contains("[Completed normally]"));
344  
345          f = new CompletableFuture<String>();
346 <        f.completeExceptionally(new IndexOutOfBoundsException());
346 >        assertTrue(f.completeExceptionally(new IndexOutOfBoundsException()));
347          assertTrue(f.toString().contains("[Completed exceptionally]"));
348 +
349 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
350 +            f = new CompletableFuture<String>();
351 +            assertTrue(f.cancel(mayInterruptIfRunning));
352 +            assertTrue(f.toString().contains("[Completed exceptionally]"));
353 +        }
354      }
355  
356      /**
# Line 320 | Line 361 | public class CompletableFutureTest exten
361          checkCompletedNormally(f, "test");
362      }
363  
364 <    static final class IntegerSupplier implements Supplier<Integer> {
324 <        final ExecutionMode m;
364 >    abstract class CheckedAction {
365          int invocationCount = 0;
366 +        final ExecutionMode m;
367 +        CheckedAction(ExecutionMode m) { this.m = m; }
368 +        void invoked() {
369 +            m.checkExecutionMode();
370 +            assertEquals(0, invocationCount++);
371 +        }
372 +        void assertNotInvoked() { assertEquals(0, invocationCount); }
373 +        void assertInvoked() { assertEquals(1, invocationCount); }
374 +    }
375 +
376 +    abstract class CheckedIntegerAction extends CheckedAction {
377 +        Integer value;
378 +        CheckedIntegerAction(ExecutionMode m) { super(m); }
379 +        void assertValue(Integer expected) {
380 +            assertInvoked();
381 +            assertEquals(expected, value);
382 +        }
383 +    }
384 +
385 +    class IntegerSupplier extends CheckedAction
386 +        implements Supplier<Integer>
387 +    {
388          final Integer value;
389          IntegerSupplier(ExecutionMode m, Integer value) {
390 <            this.m = m;
390 >            super(m);
391              this.value = value;
392          }
393          public Integer get() {
394 <            m.checkExecutionMode();
333 <            invocationCount++;
394 >            invoked();
395              return value;
396          }
397      }
# Line 340 | Line 401 | public class CompletableFutureTest exten
401          return (x == null) ? null : x + 1;
402      }
403  
404 <    static final class IncAction implements Consumer<Integer> {
405 <        int invocationCount = 0;
406 <        Integer value;
404 >    class NoopConsumer extends CheckedIntegerAction
405 >        implements Consumer<Integer>
406 >    {
407 >        NoopConsumer(ExecutionMode m) { super(m); }
408          public void accept(Integer x) {
409 <            invocationCount++;
410 <            value = inc(x);
409 >            invoked();
410 >            value = x;
411          }
412      }
413 <    static final class IncFunction implements Function<Integer,Integer> {
414 <        final ExecutionMode m;
415 <        int invocationCount = 0;
416 <        Integer value;
417 <        IncFunction(ExecutionMode m) { this.m = m; }
413 >
414 >    class IncFunction extends CheckedIntegerAction
415 >        implements Function<Integer,Integer>
416 >    {
417 >        IncFunction(ExecutionMode m) { super(m); }
418          public Integer apply(Integer x) {
419 <            m.checkExecutionMode();
358 <            invocationCount++;
419 >            invoked();
420              return value = inc(x);
421          }
422      }
# Line 368 | Line 429 | public class CompletableFutureTest exten
429              - ((y == null) ? 99 : y.intValue());
430      }
431  
432 <    static final class SubtractAction implements BiConsumer<Integer, Integer> {
433 <        final ExecutionMode m;
434 <        int invocationCount = 0;
435 <        Integer value;
375 <        // Check this action was invoked exactly once when result is computed.
376 <        SubtractAction(ExecutionMode m) { this.m = m; }
432 >    class SubtractAction extends CheckedIntegerAction
433 >        implements BiConsumer<Integer, Integer>
434 >    {
435 >        SubtractAction(ExecutionMode m) { super(m); }
436          public void accept(Integer x, Integer y) {
437 <            m.checkExecutionMode();
379 <            invocationCount++;
437 >            invoked();
438              value = subtract(x, y);
439          }
440      }
441 <    static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
442 <        final ExecutionMode m;
443 <        int invocationCount = 0;
444 <        Integer value;
445 <        // Check this action was invoked exactly once when result is computed.
388 <        SubtractFunction(ExecutionMode m) { this.m = m; }
441 >
442 >    class SubtractFunction extends CheckedIntegerAction
443 >        implements BiFunction<Integer, Integer, Integer>
444 >    {
445 >        SubtractFunction(ExecutionMode m) { super(m); }
446          public Integer apply(Integer x, Integer y) {
447 <            m.checkExecutionMode();
391 <            invocationCount++;
447 >            invoked();
448              return value = subtract(x, y);
449          }
450      }
451  
452 <    static final class Noop implements Runnable {
453 <        final ExecutionMode m;
398 <        int invocationCount = 0;
399 <        Noop(ExecutionMode m) { this.m = m; }
452 >    class Noop extends CheckedAction implements Runnable {
453 >        Noop(ExecutionMode m) { super(m); }
454          public void run() {
455 <            m.checkExecutionMode();
402 <            invocationCount++;
455 >            invoked();
456          }
457      }
458  
459 <    static final class FailingSupplier implements Supplier<Integer> {
460 <        final ExecutionMode m;
461 <        int invocationCount = 0;
462 <        FailingSupplier(ExecutionMode m) { this.m = m; }
459 >    class FailingSupplier extends CheckedAction
460 >        implements Supplier<Integer>
461 >    {
462 >        FailingSupplier(ExecutionMode m) { super(m); }
463          public Integer get() {
464 <            m.checkExecutionMode();
412 <            invocationCount++;
464 >            invoked();
465              throw new CFException();
466          }
467      }
468 <    static final class FailingConsumer implements Consumer<Integer> {
469 <        final ExecutionMode m;
470 <        int invocationCount = 0;
471 <        FailingConsumer(ExecutionMode m) { this.m = m; }
468 >
469 >    class FailingConsumer extends CheckedIntegerAction
470 >        implements Consumer<Integer>
471 >    {
472 >        FailingConsumer(ExecutionMode m) { super(m); }
473          public void accept(Integer x) {
474 <            m.checkExecutionMode();
475 <            invocationCount++;
474 >            invoked();
475 >            value = x;
476              throw new CFException();
477          }
478      }
479 <    static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
480 <        final ExecutionMode m;
481 <        int invocationCount = 0;
482 <        FailingBiConsumer(ExecutionMode m) { this.m = m; }
479 >
480 >    class FailingBiConsumer extends CheckedIntegerAction
481 >        implements BiConsumer<Integer, Integer>
482 >    {
483 >        FailingBiConsumer(ExecutionMode m) { super(m); }
484          public void accept(Integer x, Integer y) {
485 <            m.checkExecutionMode();
486 <            invocationCount++;
485 >            invoked();
486 >            value = subtract(x, y);
487              throw new CFException();
488          }
489      }
490 <    static final class FailingFunction implements Function<Integer, Integer> {
491 <        final ExecutionMode m;
492 <        int invocationCount = 0;
493 <        FailingFunction(ExecutionMode m) { this.m = m; }
490 >
491 >    class FailingFunction extends CheckedIntegerAction
492 >        implements Function<Integer, Integer>
493 >    {
494 >        FailingFunction(ExecutionMode m) { super(m); }
495          public Integer apply(Integer x) {
496 <            m.checkExecutionMode();
497 <            invocationCount++;
496 >            invoked();
497 >            value = x;
498              throw new CFException();
499          }
500      }
501 <    static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
502 <        final ExecutionMode m;
503 <        int invocationCount = 0;
504 <        FailingBiFunction(ExecutionMode m) { this.m = m; }
501 >
502 >    class FailingBiFunction extends CheckedIntegerAction
503 >        implements BiFunction<Integer, Integer, Integer>
504 >    {
505 >        FailingBiFunction(ExecutionMode m) { super(m); }
506          public Integer apply(Integer x, Integer y) {
507 <            m.checkExecutionMode();
508 <            invocationCount++;
507 >            invoked();
508 >            value = subtract(x, y);
509              throw new CFException();
510          }
511      }
512 <    static final class FailingRunnable implements Runnable {
513 <        final ExecutionMode m;
514 <        int invocationCount = 0;
459 <        FailingRunnable(ExecutionMode m) { this.m = m; }
512 >
513 >    class FailingRunnable extends CheckedAction implements Runnable {
514 >        FailingRunnable(ExecutionMode m) { super(m); }
515          public void run() {
516 <            m.checkExecutionMode();
462 <            invocationCount++;
516 >            invoked();
517              throw new CFException();
518          }
519      }
520  
521 <    static final class CompletableFutureInc
522 <        implements Function<Integer, CompletableFuture<Integer>> {
523 <        final ExecutionMode m;
524 <        int invocationCount = 0;
471 <        CompletableFutureInc(ExecutionMode m) { this.m = m; }
521 >    class CompletableFutureInc extends CheckedIntegerAction
522 >        implements Function<Integer, CompletableFuture<Integer>>
523 >    {
524 >        CompletableFutureInc(ExecutionMode m) { super(m); }
525          public CompletableFuture<Integer> apply(Integer x) {
526 <            m.checkExecutionMode();
527 <            invocationCount++;
526 >            invoked();
527 >            value = x;
528              CompletableFuture<Integer> f = new CompletableFuture<>();
529 <            f.complete(inc(x));
529 >            assertTrue(f.complete(inc(x)));
530              return f;
531          }
532      }
533  
534 <    static final class FailingCompletableFutureFunction
535 <        implements Function<Integer, CompletableFuture<Integer>> {
536 <        final ExecutionMode m;
537 <        int invocationCount = 0;
485 <        FailingCompletableFutureFunction(ExecutionMode m) { this.m = m; }
534 >    class FailingCompletableFutureFunction extends CheckedIntegerAction
535 >        implements Function<Integer, CompletableFuture<Integer>>
536 >    {
537 >        FailingCompletableFutureFunction(ExecutionMode m) { super(m); }
538          public CompletableFuture<Integer> apply(Integer x) {
539 <            m.checkExecutionMode();
540 <            invocationCount++;
539 >            invoked();
540 >            value = x;
541              throw new CFException();
542          }
543      }
# Line 504 | Line 556 | public class CompletableFutureTest exten
556          }
557      }
558  
559 +    static final boolean defaultExecutorIsCommonPool
560 +        = ForkJoinPool.getCommonPoolParallelism() > 1;
561 +
562      /**
563       * Permits the testing of parallel code for the 3 different
564       * execution modes without copy/pasting all the test methods.
565       */
566      enum ExecutionMode {
567 <        DEFAULT {
567 >        SYNC {
568              public void checkExecutionMode() {
569                  assertFalse(ThreadExecutor.startedCurrentThread());
570                  assertNull(ForkJoinTask.getPool());
# Line 585 | Line 640 | public class CompletableFutureTest exten
640  
641          ASYNC {
642              public void checkExecutionMode() {
643 <                assertSame(ForkJoinPool.commonPool(),
644 <                           ForkJoinTask.getPool());
643 >                assertEquals(defaultExecutorIsCommonPool,
644 >                             (ForkJoinPool.commonPool() == ForkJoinTask.getPool()));
645              }
646              public CompletableFuture<Void> runAsync(Runnable a) {
647                  return CompletableFuture.runAsync(a);
# Line 782 | Line 837 | public class CompletableFutureTest exten
837      {
838          final AtomicInteger a = new AtomicInteger(0);
839          final CompletableFuture<Integer> f = new CompletableFuture<>();
840 <        if (!createIncomplete) f.complete(v1);
840 >        if (!createIncomplete) assertTrue(f.complete(v1));
841          final CompletableFuture<Integer> g = f.exceptionally
842              ((Throwable t) -> {
788 –                // Should not be called
843                  a.getAndIncrement();
844 <                throw new AssertionError();
844 >                threadFail("should not be called");
845 >                return null;            // unreached
846              });
847 <        if (createIncomplete) f.complete(v1);
847 >        if (createIncomplete) assertTrue(f.complete(v1));
848  
849          checkCompletedNormally(g, v1);
850          checkCompletedNormally(f, v1);
851          assertEquals(0, a.get());
852      }}
853  
799 –
854      /**
855       * exceptionally action completes with function value on source
856       * exception
# Line 811 | Line 865 | public class CompletableFutureTest exten
865          if (!createIncomplete) f.completeExceptionally(ex);
866          final CompletableFuture<Integer> g = f.exceptionally
867              ((Throwable t) -> {
868 <                ExecutionMode.DEFAULT.checkExecutionMode();
868 >                ExecutionMode.SYNC.checkExecutionMode();
869                  threadAssertSame(t, ex);
870                  a.getAndIncrement();
871                  return v1;
# Line 824 | Line 878 | public class CompletableFutureTest exten
878  
879      public void testExceptionally_exceptionalCompletionActionFailed() {
880          for (boolean createIncomplete : new boolean[] { true, false })
827 –        for (Integer v1 : new Integer[] { 1, null })
881      {
882          final AtomicInteger a = new AtomicInteger(0);
883          final CFException ex1 = new CFException();
# Line 833 | Line 886 | public class CompletableFutureTest exten
886          if (!createIncomplete) f.completeExceptionally(ex1);
887          final CompletableFuture<Integer> g = f.exceptionally
888              ((Throwable t) -> {
889 <                ExecutionMode.DEFAULT.checkExecutionMode();
889 >                ExecutionMode.SYNC.checkExecutionMode();
890 >                threadAssertSame(t, ex1);
891 >                a.getAndIncrement();
892 >                throw ex2;
893 >            });
894 >        if (createIncomplete) f.completeExceptionally(ex1);
895 >
896 >        checkCompletedWithWrappedException(g, ex2);
897 >        assertEquals(1, a.get());
898 >    }}
899 >
900 >    /**
901 >     * whenComplete action executes on normal completion, propagating
902 >     * source result.
903 >     */
904 >    public void testWhenComplete_normalCompletion() {
905 >        for (ExecutionMode m : ExecutionMode.values())
906 >        for (boolean createIncomplete : new boolean[] { true, false })
907 >        for (Integer v1 : new Integer[] { 1, null })
908 >    {
909 >        final AtomicInteger a = new AtomicInteger(0);
910 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
911 >        if (!createIncomplete) assertTrue(f.complete(v1));
912 >        final CompletableFuture<Integer> g = m.whenComplete
913 >            (f,
914 >             (Integer x, Throwable t) -> {
915 >                m.checkExecutionMode();
916 >                threadAssertSame(x, v1);
917 >                threadAssertNull(t);
918 >                a.getAndIncrement();
919 >            });
920 >        if (createIncomplete) assertTrue(f.complete(v1));
921 >
922 >        checkCompletedNormally(g, v1);
923 >        checkCompletedNormally(f, v1);
924 >        assertEquals(1, a.get());
925 >    }}
926 >
927 >    /**
928 >     * whenComplete action executes on exceptional completion, propagating
929 >     * source result.
930 >     */
931 >    public void testWhenComplete_exceptionalCompletion() {
932 >        for (ExecutionMode m : ExecutionMode.values())
933 >        for (boolean createIncomplete : new boolean[] { true, false })
934 >    {
935 >        final AtomicInteger a = new AtomicInteger(0);
936 >        final CFException ex = new CFException();
937 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
938 >        if (!createIncomplete) f.completeExceptionally(ex);
939 >        final CompletableFuture<Integer> g = m.whenComplete
940 >            (f,
941 >             (Integer x, Throwable t) -> {
942 >                m.checkExecutionMode();
943 >                threadAssertNull(x);
944 >                threadAssertSame(t, ex);
945 >                a.getAndIncrement();
946 >            });
947 >        if (createIncomplete) f.completeExceptionally(ex);
948 >
949 >        checkCompletedWithWrappedException(g, ex);
950 >        checkCompletedExceptionally(f, ex);
951 >        assertEquals(1, a.get());
952 >    }}
953 >
954 >    /**
955 >     * whenComplete action executes on cancelled source, propagating
956 >     * CancellationException.
957 >     */
958 >    public void testWhenComplete_sourceCancelled() {
959 >        for (ExecutionMode m : ExecutionMode.values())
960 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
961 >        for (boolean createIncomplete : new boolean[] { true, false })
962 >    {
963 >        final AtomicInteger a = new AtomicInteger(0);
964 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
965 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
966 >        final CompletableFuture<Integer> g = m.whenComplete
967 >            (f,
968 >             (Integer x, Throwable t) -> {
969 >                m.checkExecutionMode();
970 >                threadAssertNull(x);
971 >                threadAssertTrue(t instanceof CancellationException);
972 >                a.getAndIncrement();
973 >            });
974 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
975 >
976 >        checkCompletedWithWrappedCancellationException(g);
977 >        checkCancelled(f);
978 >        assertEquals(1, a.get());
979 >    }}
980 >
981 >    /**
982 >     * If a whenComplete action throws an exception when triggered by
983 >     * a normal completion, it completes exceptionally
984 >     */
985 >    public void testWhenComplete_actionFailed() {
986 >        for (boolean createIncomplete : new boolean[] { true, false })
987 >        for (ExecutionMode m : ExecutionMode.values())
988 >        for (Integer v1 : new Integer[] { 1, null })
989 >    {
990 >        final AtomicInteger a = new AtomicInteger(0);
991 >        final CFException ex = new CFException();
992 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
993 >        if (!createIncomplete) assertTrue(f.complete(v1));
994 >        final CompletableFuture<Integer> g = m.whenComplete
995 >            (f,
996 >             (Integer x, Throwable t) -> {
997 >                m.checkExecutionMode();
998 >                threadAssertSame(x, v1);
999 >                threadAssertNull(t);
1000 >                a.getAndIncrement();
1001 >                throw ex;
1002 >            });
1003 >        if (createIncomplete) assertTrue(f.complete(v1));
1004 >
1005 >        checkCompletedWithWrappedException(g, ex);
1006 >        checkCompletedNormally(f, v1);
1007 >        assertEquals(1, a.get());
1008 >    }}
1009 >
1010 >    /**
1011 >     * If a whenComplete action throws an exception when triggered by
1012 >     * a source completion that also throws an exception, the source
1013 >     * exception takes precedence.
1014 >     */
1015 >    public void testWhenComplete_actionFailedSourceFailed() {
1016 >        for (boolean createIncomplete : new boolean[] { true, false })
1017 >        for (ExecutionMode m : ExecutionMode.values())
1018 >    {
1019 >        final AtomicInteger a = new AtomicInteger(0);
1020 >        final CFException ex1 = new CFException();
1021 >        final CFException ex2 = new CFException();
1022 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1023 >
1024 >        if (!createIncomplete) f.completeExceptionally(ex1);
1025 >        final CompletableFuture<Integer> g = m.whenComplete
1026 >            (f,
1027 >             (Integer x, Throwable t) -> {
1028 >                m.checkExecutionMode();
1029                  threadAssertSame(t, ex1);
1030 +                threadAssertNull(x);
1031                  a.getAndIncrement();
1032                  throw ex2;
1033              });
1034          if (createIncomplete) f.completeExceptionally(ex1);
1035  
1036 <        checkCompletedWithWrappedCFException(g, ex2);
1036 >        checkCompletedWithWrappedException(g, ex1);
1037 >        checkCompletedExceptionally(f, ex1);
1038          assertEquals(1, a.get());
1039      }}
1040  
# Line 855 | Line 1049 | public class CompletableFutureTest exten
1049      {
1050          final CompletableFuture<Integer> f = new CompletableFuture<>();
1051          final AtomicInteger a = new AtomicInteger(0);
1052 <        if (!createIncomplete) f.complete(v1);
1052 >        if (!createIncomplete) assertTrue(f.complete(v1));
1053          final CompletableFuture<Integer> g = m.handle
1054              (f,
1055               (Integer x, Throwable t) -> {
# Line 865 | Line 1059 | public class CompletableFutureTest exten
1059                  a.getAndIncrement();
1060                  return inc(v1);
1061              });
1062 <        if (createIncomplete) f.complete(v1);
1062 >        if (createIncomplete) assertTrue(f.complete(v1));
1063  
1064          checkCompletedNormally(g, inc(v1));
1065          checkCompletedNormally(f, v1);
# Line 897 | Line 1091 | public class CompletableFutureTest exten
1091          if (createIncomplete) f.completeExceptionally(ex);
1092  
1093          checkCompletedNormally(g, v1);
1094 <        checkCompletedWithWrappedCFException(f, ex);
1094 >        checkCompletedExceptionally(f, ex);
1095          assertEquals(1, a.get());
1096      }}
1097  
# Line 953 | Line 1147 | public class CompletableFutureTest exten
1147              });
1148          if (createIncomplete) f.completeExceptionally(ex1);
1149  
1150 <        checkCompletedWithWrappedCFException(g, ex2);
1151 <        checkCompletedWithWrappedCFException(f, ex1);
1150 >        checkCompletedWithWrappedException(g, ex2);
1151 >        checkCompletedExceptionally(f, ex1);
1152          assertEquals(1, a.get());
1153      }}
1154  
# Line 966 | Line 1160 | public class CompletableFutureTest exten
1160          final CompletableFuture<Integer> f = new CompletableFuture<>();
1161          final AtomicInteger a = new AtomicInteger(0);
1162          final CFException ex = new CFException();
1163 <        if (!createIncomplete) f.complete(v1);
1163 >        if (!createIncomplete) assertTrue(f.complete(v1));
1164          final CompletableFuture<Integer> g = m.handle
1165              (f,
1166               (Integer x, Throwable t) -> {
# Line 976 | Line 1170 | public class CompletableFutureTest exten
1170                  a.getAndIncrement();
1171                  throw ex;
1172              });
1173 <        if (createIncomplete) f.complete(v1);
1173 >        if (createIncomplete) assertTrue(f.complete(v1));
1174  
1175 <        checkCompletedWithWrappedCFException(g, ex);
1175 >        checkCompletedWithWrappedException(g, ex);
1176          checkCompletedNormally(f, v1);
1177          assertEquals(1, a.get());
1178      }}
# Line 997 | Line 1191 | public class CompletableFutureTest exten
1191          final CompletableFuture<Void> f = m.runAsync(r);
1192          assertNull(f.join());
1193          checkCompletedNormally(f, null);
1194 <        assertEquals(1, r.invocationCount);
1194 >        r.assertInvoked();
1195      }}
1196  
1197      /**
# Line 1013 | Line 1207 | public class CompletableFutureTest exten
1207          final FailingRunnable r = new FailingRunnable(m);
1208          final CompletableFuture<Void> f = m.runAsync(r);
1209          checkCompletedWithWrappedCFException(f);
1210 <        assertEquals(1, r.invocationCount);
1210 >        r.assertInvoked();
1211      }}
1212  
1213      /**
# Line 1031 | Line 1225 | public class CompletableFutureTest exten
1225          final CompletableFuture<Integer> f = m.supplyAsync(r);
1226          assertSame(v1, f.join());
1227          checkCompletedNormally(f, v1);
1228 <        assertEquals(1, r.invocationCount);
1228 >        r.assertInvoked();
1229      }}
1230  
1231      /**
# Line 1047 | Line 1241 | public class CompletableFutureTest exten
1241          FailingSupplier r = new FailingSupplier(m);
1242          CompletableFuture<Integer> f = m.supplyAsync(r);
1243          checkCompletedWithWrappedCFException(f);
1244 <        assertEquals(1, r.invocationCount);
1244 >        r.assertInvoked();
1245      }}
1246  
1247      // seq completion methods
# Line 1057 | Line 1251 | public class CompletableFutureTest exten
1251       */
1252      public void testThenRun_normalCompletion() {
1253          for (ExecutionMode m : ExecutionMode.values())
1060 –        for (boolean createIncomplete : new boolean[] { true, false })
1254          for (Integer v1 : new Integer[] { 1, null })
1255      {
1256          final CompletableFuture<Integer> f = new CompletableFuture<>();
1257 <        final Noop r = new Noop(m);
1258 <        if (!createIncomplete) f.complete(v1);
1066 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1067 <        if (createIncomplete) {
1068 <            checkIncomplete(g);
1069 <            f.complete(v1);
1070 <        }
1257 >        final Noop[] rs = new Noop[6];
1258 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1259  
1260 <        checkCompletedNormally(g, null);
1260 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1261 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1262 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1263 >        checkIncomplete(h0);
1264 >        checkIncomplete(h1);
1265 >        checkIncomplete(h2);
1266 >        assertTrue(f.complete(v1));
1267 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1268 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1269 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1270 >
1271 >        checkCompletedNormally(h0, null);
1272 >        checkCompletedNormally(h1, null);
1273 >        checkCompletedNormally(h2, null);
1274 >        checkCompletedNormally(h3, null);
1275 >        checkCompletedNormally(h4, null);
1276 >        checkCompletedNormally(h5, null);
1277          checkCompletedNormally(f, v1);
1278 <        assertEquals(1, r.invocationCount);
1278 >        for (Noop r : rs) r.assertInvoked();
1279      }}
1280  
1281      /**
# Line 1080 | Line 1284 | public class CompletableFutureTest exten
1284       */
1285      public void testThenRun_exceptionalCompletion() {
1286          for (ExecutionMode m : ExecutionMode.values())
1083 –        for (boolean createIncomplete : new boolean[] { true, false })
1287      {
1288          final CFException ex = new CFException();
1289          final CompletableFuture<Integer> f = new CompletableFuture<>();
1290 <        final Noop r = new Noop(m);
1291 <        if (!createIncomplete) f.completeExceptionally(ex);
1089 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1090 <        if (createIncomplete) {
1091 <            checkIncomplete(g);
1092 <            f.completeExceptionally(ex);
1093 <        }
1290 >        final Noop[] rs = new Noop[6];
1291 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1292  
1293 <        checkCompletedWithWrappedCFException(g, ex);
1294 <        checkCompletedWithWrappedCFException(f, ex);
1295 <        assertEquals(0, r.invocationCount);
1293 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1294 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1295 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1296 >        checkIncomplete(h0);
1297 >        checkIncomplete(h1);
1298 >        checkIncomplete(h2);
1299 >        assertTrue(f.completeExceptionally(ex));
1300 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1301 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1302 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1303 >
1304 >        checkCompletedWithWrappedException(h0, ex);
1305 >        checkCompletedWithWrappedException(h1, ex);
1306 >        checkCompletedWithWrappedException(h2, ex);
1307 >        checkCompletedWithWrappedException(h3, ex);
1308 >        checkCompletedWithWrappedException(h4, ex);
1309 >        checkCompletedWithWrappedException(h5, ex);
1310 >        checkCompletedExceptionally(f, ex);
1311 >        for (Noop r : rs) r.assertNotInvoked();
1312      }}
1313  
1314      /**
# Line 1102 | Line 1316 | public class CompletableFutureTest exten
1316       */
1317      public void testThenRun_sourceCancelled() {
1318          for (ExecutionMode m : ExecutionMode.values())
1105 –        for (boolean createIncomplete : new boolean[] { true, false })
1319          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1320      {
1321          final CompletableFuture<Integer> f = new CompletableFuture<>();
1322 <        final Noop r = new Noop(m);
1323 <        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1111 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1112 <        if (createIncomplete) {
1113 <            checkIncomplete(g);
1114 <            assertTrue(f.cancel(mayInterruptIfRunning));
1115 <        }
1322 >        final Noop[] rs = new Noop[6];
1323 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1324  
1325 <        checkCompletedWithWrappedCancellationException(g);
1325 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1326 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1327 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1328 >        checkIncomplete(h0);
1329 >        checkIncomplete(h1);
1330 >        checkIncomplete(h2);
1331 >        assertTrue(f.cancel(mayInterruptIfRunning));
1332 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1333 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1334 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1335 >
1336 >        checkCompletedWithWrappedCancellationException(h0);
1337 >        checkCompletedWithWrappedCancellationException(h1);
1338 >        checkCompletedWithWrappedCancellationException(h2);
1339 >        checkCompletedWithWrappedCancellationException(h3);
1340 >        checkCompletedWithWrappedCancellationException(h4);
1341 >        checkCompletedWithWrappedCancellationException(h5);
1342          checkCancelled(f);
1343 <        assertEquals(0, r.invocationCount);
1343 >        for (Noop r : rs) r.assertNotInvoked();
1344      }}
1345  
1346      /**
# Line 1124 | Line 1348 | public class CompletableFutureTest exten
1348       */
1349      public void testThenRun_actionFailed() {
1350          for (ExecutionMode m : ExecutionMode.values())
1127 –        for (boolean createIncomplete : new boolean[] { true, false })
1351          for (Integer v1 : new Integer[] { 1, null })
1352      {
1353          final CompletableFuture<Integer> f = new CompletableFuture<>();
1354 <        final FailingRunnable r = new FailingRunnable(m);
1355 <        if (!createIncomplete) f.complete(v1);
1133 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1134 <        if (createIncomplete) {
1135 <            checkIncomplete(g);
1136 <            f.complete(v1);
1137 <        }
1354 >        final FailingRunnable[] rs = new FailingRunnable[6];
1355 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
1356  
1357 <        checkCompletedWithWrappedCFException(g);
1357 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1358 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1359 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1360 >        assertTrue(f.complete(v1));
1361 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1362 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1363 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1364 >
1365 >        checkCompletedWithWrappedCFException(h0);
1366 >        checkCompletedWithWrappedCFException(h1);
1367 >        checkCompletedWithWrappedCFException(h2);
1368 >        checkCompletedWithWrappedCFException(h3);
1369 >        checkCompletedWithWrappedCFException(h4);
1370 >        checkCompletedWithWrappedCFException(h5);
1371          checkCompletedNormally(f, v1);
1372      }}
1373  
# Line 1145 | Line 1376 | public class CompletableFutureTest exten
1376       */
1377      public void testThenApply_normalCompletion() {
1378          for (ExecutionMode m : ExecutionMode.values())
1148 –        for (boolean createIncomplete : new boolean[] { true, false })
1379          for (Integer v1 : new Integer[] { 1, null })
1380      {
1381          final CompletableFuture<Integer> f = new CompletableFuture<>();
1382 <        final IncFunction r = new IncFunction(m);
1383 <        if (!createIncomplete) f.complete(v1);
1154 <        final CompletableFuture<Integer> g = m.thenApply(f, r);
1155 <        if (createIncomplete) {
1156 <            checkIncomplete(g);
1157 <            f.complete(v1);
1158 <        }
1382 >        final IncFunction[] rs = new IncFunction[4];
1383 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1384  
1385 <        checkCompletedNormally(g, inc(v1));
1385 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1386 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1387 >        checkIncomplete(h0);
1388 >        checkIncomplete(h1);
1389 >        assertTrue(f.complete(v1));
1390 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1391 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1392 >
1393 >        checkCompletedNormally(h0, inc(v1));
1394 >        checkCompletedNormally(h1, inc(v1));
1395 >        checkCompletedNormally(h2, inc(v1));
1396 >        checkCompletedNormally(h3, inc(v1));
1397          checkCompletedNormally(f, v1);
1398 <        assertEquals(1, r.invocationCount);
1398 >        for (IncFunction r : rs) r.assertValue(inc(v1));
1399      }}
1400  
1401      /**
# Line 1168 | Line 1404 | public class CompletableFutureTest exten
1404       */
1405      public void testThenApply_exceptionalCompletion() {
1406          for (ExecutionMode m : ExecutionMode.values())
1171 –        for (boolean createIncomplete : new boolean[] { true, false })
1407      {
1408          final CFException ex = new CFException();
1409          final CompletableFuture<Integer> f = new CompletableFuture<>();
1410 <        final IncFunction r = new IncFunction(m);
1411 <        if (!createIncomplete) f.completeExceptionally(ex);
1177 <        final CompletableFuture<Integer> g = m.thenApply(f, r);
1178 <        if (createIncomplete) {
1179 <            checkIncomplete(g);
1180 <            f.completeExceptionally(ex);
1181 <        }
1410 >        final IncFunction[] rs = new IncFunction[4];
1411 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1412  
1413 <        checkCompletedWithWrappedCFException(g, ex);
1414 <        checkCompletedWithWrappedCFException(f, ex);
1415 <        assertEquals(0, r.invocationCount);
1413 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1414 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1415 >        assertTrue(f.completeExceptionally(ex));
1416 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1417 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1418 >
1419 >        checkCompletedWithWrappedException(h0, ex);
1420 >        checkCompletedWithWrappedException(h1, ex);
1421 >        checkCompletedWithWrappedException(h2, ex);
1422 >        checkCompletedWithWrappedException(h3, ex);
1423 >        checkCompletedExceptionally(f, ex);
1424 >        for (IncFunction r : rs) r.assertNotInvoked();
1425      }}
1426  
1427      /**
# Line 1190 | Line 1429 | public class CompletableFutureTest exten
1429       */
1430      public void testThenApply_sourceCancelled() {
1431          for (ExecutionMode m : ExecutionMode.values())
1193 –        for (boolean createIncomplete : new boolean[] { true, false })
1432          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1433      {
1434          final CompletableFuture<Integer> f = new CompletableFuture<>();
1435 <        final IncFunction r = new IncFunction(m);
1436 <        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1199 <        final CompletableFuture<Integer> g = m.thenApply(f, r);
1200 <        if (createIncomplete) {
1201 <            checkIncomplete(g);
1202 <            assertTrue(f.cancel(mayInterruptIfRunning));
1203 <        }
1435 >        final IncFunction[] rs = new IncFunction[4];
1436 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1437  
1438 <        checkCompletedWithWrappedCancellationException(g);
1438 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1439 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1440 >        assertTrue(f.cancel(mayInterruptIfRunning));
1441 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1442 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1443 >
1444 >        checkCompletedWithWrappedCancellationException(h0);
1445 >        checkCompletedWithWrappedCancellationException(h1);
1446 >        checkCompletedWithWrappedCancellationException(h2);
1447 >        checkCompletedWithWrappedCancellationException(h3);
1448          checkCancelled(f);
1449 <        assertEquals(0, r.invocationCount);
1449 >        for (IncFunction r : rs) r.assertNotInvoked();
1450      }}
1451  
1452      /**
# Line 1212 | Line 1454 | public class CompletableFutureTest exten
1454       */
1455      public void testThenApply_actionFailed() {
1456          for (ExecutionMode m : ExecutionMode.values())
1215 –        for (boolean createIncomplete : new boolean[] { true, false })
1457          for (Integer v1 : new Integer[] { 1, null })
1458      {
1459          final CompletableFuture<Integer> f = new CompletableFuture<>();
1460 <        final FailingFunction r = new FailingFunction(m);
1461 <        if (!createIncomplete) f.complete(v1);
1221 <        final CompletableFuture<Integer> g = m.thenApply(f, r);
1222 <        if (createIncomplete) {
1223 <            checkIncomplete(g);
1224 <            f.complete(v1);
1225 <        }
1460 >        final FailingFunction[] rs = new FailingFunction[4];
1461 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1462  
1463 <        checkCompletedWithWrappedCFException(g);
1463 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1464 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1465 >        assertTrue(f.complete(v1));
1466 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1467 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1468 >
1469 >        checkCompletedWithWrappedCFException(h0);
1470 >        checkCompletedWithWrappedCFException(h1);
1471 >        checkCompletedWithWrappedCFException(h2);
1472 >        checkCompletedWithWrappedCFException(h3);
1473          checkCompletedNormally(f, v1);
1474      }}
1475  
# Line 1233 | Line 1478 | public class CompletableFutureTest exten
1478       */
1479      public void testThenAccept_normalCompletion() {
1480          for (ExecutionMode m : ExecutionMode.values())
1236 –        for (boolean createIncomplete : new boolean[] { true, false })
1481          for (Integer v1 : new Integer[] { 1, null })
1482      {
1483          final CompletableFuture<Integer> f = new CompletableFuture<>();
1484 <        final IncAction r = new IncAction();
1485 <        if (!createIncomplete) f.complete(v1);
1242 <        final CompletableFuture<Void> g = m.thenAccept(f, r);
1243 <        if (createIncomplete) {
1244 <            checkIncomplete(g);
1245 <            f.complete(v1);
1246 <        }
1484 >        final NoopConsumer[] rs = new NoopConsumer[4];
1485 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1486  
1487 <        checkCompletedNormally(g, null);
1487 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1488 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1489 >        checkIncomplete(h0);
1490 >        checkIncomplete(h1);
1491 >        assertTrue(f.complete(v1));
1492 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1493 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1494 >
1495 >        checkCompletedNormally(h0, null);
1496 >        checkCompletedNormally(h1, null);
1497 >        checkCompletedNormally(h2, null);
1498 >        checkCompletedNormally(h3, null);
1499          checkCompletedNormally(f, v1);
1500 <        assertEquals(1, r.invocationCount);
1251 <        assertEquals(inc(v1), r.value);
1500 >        for (NoopConsumer r : rs) r.assertValue(v1);
1501      }}
1502  
1503      /**
# Line 1257 | Line 1506 | public class CompletableFutureTest exten
1506       */
1507      public void testThenAccept_exceptionalCompletion() {
1508          for (ExecutionMode m : ExecutionMode.values())
1260 –        for (boolean createIncomplete : new boolean[] { true, false })
1509      {
1510          final CFException ex = new CFException();
1511          final CompletableFuture<Integer> f = new CompletableFuture<>();
1512 <        final IncAction r = new IncAction();
1513 <        if (!createIncomplete) f.completeExceptionally(ex);
1266 <        final CompletableFuture<Void> g = m.thenAccept(f, r);
1267 <        if (createIncomplete) {
1268 <            checkIncomplete(g);
1269 <            f.completeExceptionally(ex);
1270 <        }
1512 >        final NoopConsumer[] rs = new NoopConsumer[4];
1513 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1514  
1515 <        checkCompletedWithWrappedCFException(g, ex);
1516 <        checkCompletedWithWrappedCFException(f, ex);
1517 <        assertEquals(0, r.invocationCount);
1515 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1516 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1517 >        assertTrue(f.completeExceptionally(ex));
1518 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1519 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1520 >
1521 >        checkCompletedWithWrappedException(h0, ex);
1522 >        checkCompletedWithWrappedException(h1, ex);
1523 >        checkCompletedWithWrappedException(h2, ex);
1524 >        checkCompletedWithWrappedException(h3, ex);
1525 >        checkCompletedExceptionally(f, ex);
1526 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1527      }}
1528  
1529      /**
# Line 1279 | Line 1531 | public class CompletableFutureTest exten
1531       */
1532      public void testThenAccept_sourceCancelled() {
1533          for (ExecutionMode m : ExecutionMode.values())
1282 –        for (boolean createIncomplete : new boolean[] { true, false })
1534          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1535      {
1536          final CompletableFuture<Integer> f = new CompletableFuture<>();
1537 <        final IncAction r = new IncAction();
1538 <        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1288 <        final CompletableFuture<Void> g = m.thenAccept(f, r);
1289 <        if (createIncomplete) {
1290 <            checkIncomplete(g);
1291 <            assertTrue(f.cancel(mayInterruptIfRunning));
1292 <        }
1537 >        final NoopConsumer[] rs = new NoopConsumer[4];
1538 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1539  
1540 <        checkCompletedWithWrappedCancellationException(g);
1540 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1541 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1542 >        assertTrue(f.cancel(mayInterruptIfRunning));
1543 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1544 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1545 >
1546 >        checkCompletedWithWrappedCancellationException(h0);
1547 >        checkCompletedWithWrappedCancellationException(h1);
1548 >        checkCompletedWithWrappedCancellationException(h2);
1549 >        checkCompletedWithWrappedCancellationException(h3);
1550          checkCancelled(f);
1551 <        assertEquals(0, r.invocationCount);
1551 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1552      }}
1553  
1554      /**
# Line 1301 | Line 1556 | public class CompletableFutureTest exten
1556       */
1557      public void testThenAccept_actionFailed() {
1558          for (ExecutionMode m : ExecutionMode.values())
1304 –        for (boolean createIncomplete : new boolean[] { true, false })
1559          for (Integer v1 : new Integer[] { 1, null })
1560      {
1561          final CompletableFuture<Integer> f = new CompletableFuture<>();
1562 <        final FailingConsumer r = new FailingConsumer(m);
1563 <        if (!createIncomplete) f.complete(v1);
1310 <        final CompletableFuture<Void> g = m.thenAccept(f, r);
1311 <        if (createIncomplete) {
1312 <            checkIncomplete(g);
1313 <            f.complete(v1);
1314 <        }
1562 >        final FailingConsumer[] rs = new FailingConsumer[4];
1563 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
1564  
1565 <        checkCompletedWithWrappedCFException(g);
1565 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1566 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1567 >        assertTrue(f.complete(v1));
1568 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1569 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1570 >
1571 >        checkCompletedWithWrappedCFException(h0);
1572 >        checkCompletedWithWrappedCFException(h1);
1573 >        checkCompletedWithWrappedCFException(h2);
1574 >        checkCompletedWithWrappedCFException(h3);
1575          checkCompletedNormally(f, v1);
1576      }}
1577  
# Line 1323 | Line 1581 | public class CompletableFutureTest exten
1581       */
1582      public void testThenCombine_normalCompletion() {
1583          for (ExecutionMode m : ExecutionMode.values())
1326 –        for (boolean createIncomplete : new boolean[] { true, false })
1584          for (boolean fFirst : new boolean[] { true, false })
1585          for (Integer v1 : new Integer[] { 1, null })
1586          for (Integer v2 : new Integer[] { 2, null })
1587      {
1588          final CompletableFuture<Integer> f = new CompletableFuture<>();
1589          final CompletableFuture<Integer> g = new CompletableFuture<>();
1590 <        final SubtractFunction r = new SubtractFunction(m);
1590 >        final SubtractFunction[] rs = new SubtractFunction[6];
1591 >        for (int i = 0; i < rs.length; i++) rs[i] = new SubtractFunction(m);
1592  
1593 <        if (fFirst) f.complete(v1); else g.complete(v2);
1594 <        if (!createIncomplete)
1595 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1596 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1597 <        if (createIncomplete) {
1598 <            checkIncomplete(h);
1599 <            assertEquals(0, r.invocationCount);
1600 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1601 <        }
1593 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1594 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1595 >        final Integer w1 =  fFirst ? v1 : v2;
1596 >        final Integer w2 = !fFirst ? v1 : v2;
1597 >
1598 >        final CompletableFuture<Integer> h0 = m.thenCombine(f, g, rs[0]);
1599 >        final CompletableFuture<Integer> h1 = m.thenCombine(fst, fst, rs[1]);
1600 >        assertTrue(fst.complete(w1));
1601 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, rs[2]);
1602 >        final CompletableFuture<Integer> h3 = m.thenCombine(fst, fst, rs[3]);
1603 >        checkIncomplete(h0); rs[0].assertNotInvoked();
1604 >        checkIncomplete(h2); rs[2].assertNotInvoked();
1605 >        checkCompletedNormally(h1, subtract(w1, w1));
1606 >        checkCompletedNormally(h3, subtract(w1, w1));
1607 >        rs[1].assertValue(subtract(w1, w1));
1608 >        rs[3].assertValue(subtract(w1, w1));
1609 >        assertTrue(snd.complete(w2));
1610 >        final CompletableFuture<Integer> h4 = m.thenCombine(f, g, rs[4]);
1611 >
1612 >        checkCompletedNormally(h0, subtract(v1, v2));
1613 >        checkCompletedNormally(h2, subtract(v1, v2));
1614 >        checkCompletedNormally(h4, subtract(v1, v2));
1615 >        rs[0].assertValue(subtract(v1, v2));
1616 >        rs[2].assertValue(subtract(v1, v2));
1617 >        rs[4].assertValue(subtract(v1, v2));
1618  
1345 –        checkCompletedNormally(h, subtract(v1, v2));
1619          checkCompletedNormally(f, v1);
1620          checkCompletedNormally(g, v2);
1348 –        assertEquals(1, r.invocationCount);
1621      }}
1622  
1623      /**
1624       * thenCombine result completes exceptionally after exceptional
1625       * completion of either source
1626       */
1627 <    public void testThenCombine_exceptionalCompletion() {
1627 >    public void testThenCombine_exceptionalCompletion() throws Throwable {
1628          for (ExecutionMode m : ExecutionMode.values())
1357 –        for (boolean createIncomplete : new boolean[] { true, false })
1629          for (boolean fFirst : new boolean[] { true, false })
1630 +        for (boolean failFirst : new boolean[] { true, false })
1631          for (Integer v1 : new Integer[] { 1, null })
1632      {
1633          final CompletableFuture<Integer> f = new CompletableFuture<>();
1634          final CompletableFuture<Integer> g = new CompletableFuture<>();
1635          final CFException ex = new CFException();
1636 <        final SubtractFunction r = new SubtractFunction(m);
1637 <
1638 <        (fFirst ? f : g).complete(v1);
1639 <        if (!createIncomplete)
1640 <            (!fFirst ? f : g).completeExceptionally(ex);
1641 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1642 <        if (createIncomplete) {
1643 <            checkIncomplete(h);
1644 <            (!fFirst ? f : g).completeExceptionally(ex);
1645 <        }
1646 <
1647 <        checkCompletedWithWrappedCFException(h, ex);
1648 <        assertEquals(0, r.invocationCount);
1649 <        checkCompletedNormally(fFirst ? f : g, v1);
1650 <        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1636 >        final SubtractFunction r1 = new SubtractFunction(m);
1637 >        final SubtractFunction r2 = new SubtractFunction(m);
1638 >        final SubtractFunction r3 = new SubtractFunction(m);
1639 >
1640 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1641 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1642 >        final Callable<Boolean> complete1 = failFirst ?
1643 >            () -> fst.completeExceptionally(ex) :
1644 >            () -> fst.complete(v1);
1645 >        final Callable<Boolean> complete2 = failFirst ?
1646 >            () -> snd.complete(v1) :
1647 >            () -> snd.completeExceptionally(ex);
1648 >
1649 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1650 >        assertTrue(complete1.call());
1651 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1652 >        checkIncomplete(h1);
1653 >        checkIncomplete(h2);
1654 >        assertTrue(complete2.call());
1655 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1656 >
1657 >        checkCompletedWithWrappedException(h1, ex);
1658 >        checkCompletedWithWrappedException(h2, ex);
1659 >        checkCompletedWithWrappedException(h3, ex);
1660 >        r1.assertNotInvoked();
1661 >        r2.assertNotInvoked();
1662 >        r3.assertNotInvoked();
1663 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1664 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1665      }}
1666  
1667      /**
1668       * thenCombine result completes exceptionally if either source cancelled
1669       */
1670 <    public void testThenCombine_sourceCancelled() {
1670 >    public void testThenCombine_sourceCancelled() throws Throwable {
1671          for (ExecutionMode m : ExecutionMode.values())
1672          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1387 –        for (boolean createIncomplete : new boolean[] { true, false })
1673          for (boolean fFirst : new boolean[] { true, false })
1674 +        for (boolean failFirst : new boolean[] { true, false })
1675          for (Integer v1 : new Integer[] { 1, null })
1676      {
1677          final CompletableFuture<Integer> f = new CompletableFuture<>();
1678          final CompletableFuture<Integer> g = new CompletableFuture<>();
1679 <        final SubtractFunction r = new SubtractFunction(m);
1680 <
1681 <        (fFirst ? f : g).complete(v1);
1682 <        if (!createIncomplete)
1683 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1684 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1685 <        if (createIncomplete) {
1686 <            checkIncomplete(h);
1687 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1688 <        }
1689 <
1690 <        checkCompletedWithWrappedCancellationException(h);
1691 <        checkCancelled(!fFirst ? f : g);
1692 <        assertEquals(0, r.invocationCount);
1693 <        checkCompletedNormally(fFirst ? f : g, v1);
1679 >        final SubtractFunction r1 = new SubtractFunction(m);
1680 >        final SubtractFunction r2 = new SubtractFunction(m);
1681 >        final SubtractFunction r3 = new SubtractFunction(m);
1682 >
1683 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1684 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1685 >        final Callable<Boolean> complete1 = failFirst ?
1686 >            () -> fst.cancel(mayInterruptIfRunning) :
1687 >            () -> fst.complete(v1);
1688 >        final Callable<Boolean> complete2 = failFirst ?
1689 >            () -> snd.complete(v1) :
1690 >            () -> snd.cancel(mayInterruptIfRunning);
1691 >
1692 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1693 >        assertTrue(complete1.call());
1694 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1695 >        checkIncomplete(h1);
1696 >        checkIncomplete(h2);
1697 >        assertTrue(complete2.call());
1698 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1699 >
1700 >        checkCompletedWithWrappedCancellationException(h1);
1701 >        checkCompletedWithWrappedCancellationException(h2);
1702 >        checkCompletedWithWrappedCancellationException(h3);
1703 >        r1.assertNotInvoked();
1704 >        r2.assertNotInvoked();
1705 >        r3.assertNotInvoked();
1706 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1707 >        checkCancelled(failFirst ? fst : snd);
1708      }}
1709  
1710      /**
# Line 1418 | Line 1718 | public class CompletableFutureTest exten
1718      {
1719          final CompletableFuture<Integer> f = new CompletableFuture<>();
1720          final CompletableFuture<Integer> g = new CompletableFuture<>();
1721 <        final FailingBiFunction r = new FailingBiFunction(m);
1722 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1721 >        final FailingBiFunction r1 = new FailingBiFunction(m);
1722 >        final FailingBiFunction r2 = new FailingBiFunction(m);
1723 >        final FailingBiFunction r3 = new FailingBiFunction(m);
1724 >
1725 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1726 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1727 >        final Integer w1 =  fFirst ? v1 : v2;
1728 >        final Integer w2 = !fFirst ? v1 : v2;
1729 >
1730 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1731 >        assertTrue(fst.complete(w1));
1732 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1733 >        assertTrue(snd.complete(w2));
1734 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1735  
1736 <        if (fFirst) {
1737 <            f.complete(v1);
1738 <            g.complete(v2);
1739 <        } else {
1740 <            g.complete(v2);
1741 <            f.complete(v1);
1430 <        }
1431 <
1432 <        checkCompletedWithWrappedCFException(h);
1736 >        checkCompletedWithWrappedCFException(h1);
1737 >        checkCompletedWithWrappedCFException(h2);
1738 >        checkCompletedWithWrappedCFException(h3);
1739 >        r1.assertInvoked();
1740 >        r2.assertInvoked();
1741 >        r3.assertInvoked();
1742          checkCompletedNormally(f, v1);
1743          checkCompletedNormally(g, v2);
1744      }}
# Line 1440 | Line 1749 | public class CompletableFutureTest exten
1749       */
1750      public void testThenAcceptBoth_normalCompletion() {
1751          for (ExecutionMode m : ExecutionMode.values())
1443 –        for (boolean createIncomplete : new boolean[] { true, false })
1752          for (boolean fFirst : new boolean[] { true, false })
1753          for (Integer v1 : new Integer[] { 1, null })
1754          for (Integer v2 : new Integer[] { 2, null })
1755      {
1756          final CompletableFuture<Integer> f = new CompletableFuture<>();
1757          final CompletableFuture<Integer> g = new CompletableFuture<>();
1758 <        final SubtractAction r = new SubtractAction(m);
1759 <
1760 <        if (fFirst) f.complete(v1); else g.complete(v2);
1761 <        if (!createIncomplete)
1762 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1763 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1764 <        if (createIncomplete) {
1765 <            checkIncomplete(h);
1766 <            assertEquals(0, r.invocationCount);
1767 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1768 <        }
1769 <
1770 <        checkCompletedNormally(h, null);
1771 <        assertEquals(subtract(v1, v2), r.value);
1758 >        final SubtractAction r1 = new SubtractAction(m);
1759 >        final SubtractAction r2 = new SubtractAction(m);
1760 >        final SubtractAction r3 = new SubtractAction(m);
1761 >
1762 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1763 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1764 >        final Integer w1 =  fFirst ? v1 : v2;
1765 >        final Integer w2 = !fFirst ? v1 : v2;
1766 >
1767 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1768 >        assertTrue(fst.complete(w1));
1769 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1770 >        checkIncomplete(h1);
1771 >        checkIncomplete(h2);
1772 >        r1.assertNotInvoked();
1773 >        r2.assertNotInvoked();
1774 >        assertTrue(snd.complete(w2));
1775 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1776 >
1777 >        checkCompletedNormally(h1, null);
1778 >        checkCompletedNormally(h2, null);
1779 >        checkCompletedNormally(h3, null);
1780 >        r1.assertValue(subtract(v1, v2));
1781 >        r2.assertValue(subtract(v1, v2));
1782 >        r3.assertValue(subtract(v1, v2));
1783          checkCompletedNormally(f, v1);
1784          checkCompletedNormally(g, v2);
1785      }}
# Line 1469 | Line 1788 | public class CompletableFutureTest exten
1788       * thenAcceptBoth result completes exceptionally after exceptional
1789       * completion of either source
1790       */
1791 <    public void testThenAcceptBoth_exceptionalCompletion() {
1791 >    public void testThenAcceptBoth_exceptionalCompletion() throws Throwable {
1792          for (ExecutionMode m : ExecutionMode.values())
1474 –        for (boolean createIncomplete : new boolean[] { true, false })
1793          for (boolean fFirst : new boolean[] { true, false })
1794 +        for (boolean failFirst : new boolean[] { true, false })
1795          for (Integer v1 : new Integer[] { 1, null })
1796      {
1797          final CompletableFuture<Integer> f = new CompletableFuture<>();
1798          final CompletableFuture<Integer> g = new CompletableFuture<>();
1799          final CFException ex = new CFException();
1800 <        final SubtractAction r = new SubtractAction(m);
1801 <
1802 <        (fFirst ? f : g).complete(v1);
1803 <        if (!createIncomplete)
1804 <            (!fFirst ? f : g).completeExceptionally(ex);
1805 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1806 <        if (createIncomplete) {
1807 <            checkIncomplete(h);
1808 <            (!fFirst ? f : g).completeExceptionally(ex);
1809 <        }
1810 <
1811 <        checkCompletedWithWrappedCFException(h, ex);
1812 <        assertEquals(0, r.invocationCount);
1813 <        checkCompletedNormally(fFirst ? f : g, v1);
1814 <        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1800 >        final SubtractAction r1 = new SubtractAction(m);
1801 >        final SubtractAction r2 = new SubtractAction(m);
1802 >        final SubtractAction r3 = new SubtractAction(m);
1803 >
1804 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1805 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1806 >        final Callable<Boolean> complete1 = failFirst ?
1807 >            () -> fst.completeExceptionally(ex) :
1808 >            () -> fst.complete(v1);
1809 >        final Callable<Boolean> complete2 = failFirst ?
1810 >            () -> snd.complete(v1) :
1811 >            () -> snd.completeExceptionally(ex);
1812 >
1813 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1814 >        assertTrue(complete1.call());
1815 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1816 >        checkIncomplete(h1);
1817 >        checkIncomplete(h2);
1818 >        assertTrue(complete2.call());
1819 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1820 >
1821 >        checkCompletedWithWrappedException(h1, ex);
1822 >        checkCompletedWithWrappedException(h2, ex);
1823 >        checkCompletedWithWrappedException(h3, ex);
1824 >        r1.assertNotInvoked();
1825 >        r2.assertNotInvoked();
1826 >        r3.assertNotInvoked();
1827 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1828 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1829      }}
1830  
1831      /**
1832       * thenAcceptBoth result completes exceptionally if either source cancelled
1833       */
1834 <    public void testThenAcceptBoth_sourceCancelled() {
1834 >    public void testThenAcceptBoth_sourceCancelled() throws Throwable {
1835          for (ExecutionMode m : ExecutionMode.values())
1836          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1504 –        for (boolean createIncomplete : new boolean[] { true, false })
1837          for (boolean fFirst : new boolean[] { true, false })
1838 +        for (boolean failFirst : new boolean[] { true, false })
1839          for (Integer v1 : new Integer[] { 1, null })
1840      {
1841          final CompletableFuture<Integer> f = new CompletableFuture<>();
1842          final CompletableFuture<Integer> g = new CompletableFuture<>();
1843 <        final SubtractAction r = new SubtractAction(m);
1844 <
1845 <        (fFirst ? f : g).complete(v1);
1846 <        if (!createIncomplete)
1847 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1848 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1849 <        if (createIncomplete) {
1850 <            checkIncomplete(h);
1851 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1852 <        }
1853 <
1854 <        checkCompletedWithWrappedCancellationException(h);
1855 <        checkCancelled(!fFirst ? f : g);
1856 <        assertEquals(0, r.invocationCount);
1857 <        checkCompletedNormally(fFirst ? f : g, v1);
1843 >        final SubtractAction r1 = new SubtractAction(m);
1844 >        final SubtractAction r2 = new SubtractAction(m);
1845 >        final SubtractAction r3 = new SubtractAction(m);
1846 >
1847 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1848 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1849 >        final Callable<Boolean> complete1 = failFirst ?
1850 >            () -> fst.cancel(mayInterruptIfRunning) :
1851 >            () -> fst.complete(v1);
1852 >        final Callable<Boolean> complete2 = failFirst ?
1853 >            () -> snd.complete(v1) :
1854 >            () -> snd.cancel(mayInterruptIfRunning);
1855 >
1856 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1857 >        assertTrue(complete1.call());
1858 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1859 >        checkIncomplete(h1);
1860 >        checkIncomplete(h2);
1861 >        assertTrue(complete2.call());
1862 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1863 >
1864 >        checkCompletedWithWrappedCancellationException(h1);
1865 >        checkCompletedWithWrappedCancellationException(h2);
1866 >        checkCompletedWithWrappedCancellationException(h3);
1867 >        r1.assertNotInvoked();
1868 >        r2.assertNotInvoked();
1869 >        r3.assertNotInvoked();
1870 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1871 >        checkCancelled(failFirst ? fst : snd);
1872      }}
1873  
1874      /**
# Line 1535 | Line 1882 | public class CompletableFutureTest exten
1882      {
1883          final CompletableFuture<Integer> f = new CompletableFuture<>();
1884          final CompletableFuture<Integer> g = new CompletableFuture<>();
1885 <        final FailingBiConsumer r = new FailingBiConsumer(m);
1886 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1887 <
1888 <        if (fFirst) {
1889 <            f.complete(v1);
1890 <            g.complete(v2);
1891 <        } else {
1892 <            g.complete(v2);
1893 <            f.complete(v1);
1894 <        }
1885 >        final FailingBiConsumer r1 = new FailingBiConsumer(m);
1886 >        final FailingBiConsumer r2 = new FailingBiConsumer(m);
1887 >        final FailingBiConsumer r3 = new FailingBiConsumer(m);
1888 >
1889 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1890 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1891 >        final Integer w1 =  fFirst ? v1 : v2;
1892 >        final Integer w2 = !fFirst ? v1 : v2;
1893 >
1894 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1895 >        assertTrue(fst.complete(w1));
1896 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1897 >        assertTrue(snd.complete(w2));
1898 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1899  
1900 <        checkCompletedWithWrappedCFException(h);
1900 >        checkCompletedWithWrappedCFException(h1);
1901 >        checkCompletedWithWrappedCFException(h2);
1902 >        checkCompletedWithWrappedCFException(h3);
1903 >        r1.assertInvoked();
1904 >        r2.assertInvoked();
1905 >        r3.assertInvoked();
1906          checkCompletedNormally(f, v1);
1907          checkCompletedNormally(g, v2);
1908      }}
# Line 1557 | Line 1913 | public class CompletableFutureTest exten
1913       */
1914      public void testRunAfterBoth_normalCompletion() {
1915          for (ExecutionMode m : ExecutionMode.values())
1560 –        for (boolean createIncomplete : new boolean[] { true, false })
1916          for (boolean fFirst : new boolean[] { true, false })
1917          for (Integer v1 : new Integer[] { 1, null })
1918          for (Integer v2 : new Integer[] { 2, null })
1919      {
1920          final CompletableFuture<Integer> f = new CompletableFuture<>();
1921          final CompletableFuture<Integer> g = new CompletableFuture<>();
1922 <        final Noop r = new Noop(m);
1923 <
1924 <        if (fFirst) f.complete(v1); else g.complete(v2);
1925 <        if (!createIncomplete)
1926 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1927 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1928 <        if (createIncomplete) {
1929 <            checkIncomplete(h);
1930 <            assertEquals(0, r.invocationCount);
1931 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1932 <        }
1933 <
1934 <        checkCompletedNormally(h, null);
1935 <        assertEquals(1, r.invocationCount);
1922 >        final Noop r1 = new Noop(m);
1923 >        final Noop r2 = new Noop(m);
1924 >        final Noop r3 = new Noop(m);
1925 >
1926 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1927 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1928 >        final Integer w1 =  fFirst ? v1 : v2;
1929 >        final Integer w2 = !fFirst ? v1 : v2;
1930 >
1931 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1932 >        assertTrue(fst.complete(w1));
1933 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1934 >        checkIncomplete(h1);
1935 >        checkIncomplete(h2);
1936 >        r1.assertNotInvoked();
1937 >        r2.assertNotInvoked();
1938 >        assertTrue(snd.complete(w2));
1939 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
1940 >
1941 >        checkCompletedNormally(h1, null);
1942 >        checkCompletedNormally(h2, null);
1943 >        checkCompletedNormally(h3, null);
1944 >        r1.assertInvoked();
1945 >        r2.assertInvoked();
1946 >        r3.assertInvoked();
1947          checkCompletedNormally(f, v1);
1948          checkCompletedNormally(g, v2);
1949      }}
# Line 1586 | Line 1952 | public class CompletableFutureTest exten
1952       * runAfterBoth result completes exceptionally after exceptional
1953       * completion of either source
1954       */
1955 <    public void testRunAfterBoth_exceptionalCompletion() {
1955 >    public void testRunAfterBoth_exceptionalCompletion() throws Throwable {
1956          for (ExecutionMode m : ExecutionMode.values())
1591 –        for (boolean createIncomplete : new boolean[] { true, false })
1957          for (boolean fFirst : new boolean[] { true, false })
1958 +        for (boolean failFirst : new boolean[] { true, false })
1959          for (Integer v1 : new Integer[] { 1, null })
1960      {
1961          final CompletableFuture<Integer> f = new CompletableFuture<>();
1962          final CompletableFuture<Integer> g = new CompletableFuture<>();
1963          final CFException ex = new CFException();
1964 <        final Noop r = new Noop(m);
1965 <
1966 <        (fFirst ? f : g).complete(v1);
1967 <        if (!createIncomplete)
1968 <            (!fFirst ? f : g).completeExceptionally(ex);
1969 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1970 <        if (createIncomplete) {
1971 <            checkIncomplete(h);
1972 <            (!fFirst ? f : g).completeExceptionally(ex);
1973 <        }
1974 <
1975 <        checkCompletedWithWrappedCFException(h, ex);
1976 <        assertEquals(0, r.invocationCount);
1977 <        checkCompletedNormally(fFirst ? f : g, v1);
1978 <        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1964 >        final Noop r1 = new Noop(m);
1965 >        final Noop r2 = new Noop(m);
1966 >        final Noop r3 = new Noop(m);
1967 >
1968 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1969 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1970 >        final Callable<Boolean> complete1 = failFirst ?
1971 >            () -> fst.completeExceptionally(ex) :
1972 >            () -> fst.complete(v1);
1973 >        final Callable<Boolean> complete2 = failFirst ?
1974 >            () -> snd.complete(v1) :
1975 >            () -> snd.completeExceptionally(ex);
1976 >
1977 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1978 >        assertTrue(complete1.call());
1979 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1980 >        checkIncomplete(h1);
1981 >        checkIncomplete(h2);
1982 >        assertTrue(complete2.call());
1983 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
1984 >
1985 >        checkCompletedWithWrappedException(h1, ex);
1986 >        checkCompletedWithWrappedException(h2, ex);
1987 >        checkCompletedWithWrappedException(h3, ex);
1988 >        r1.assertNotInvoked();
1989 >        r2.assertNotInvoked();
1990 >        r3.assertNotInvoked();
1991 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1992 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1993      }}
1994  
1995      /**
1996       * runAfterBoth result completes exceptionally if either source cancelled
1997       */
1998 <    public void testRunAfterBoth_sourceCancelled() {
1998 >    public void testRunAfterBoth_sourceCancelled() throws Throwable {
1999          for (ExecutionMode m : ExecutionMode.values())
2000          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1621 –        for (boolean createIncomplete : new boolean[] { true, false })
2001          for (boolean fFirst : new boolean[] { true, false })
2002 +        for (boolean failFirst : new boolean[] { true, false })
2003          for (Integer v1 : new Integer[] { 1, null })
2004      {
2005          final CompletableFuture<Integer> f = new CompletableFuture<>();
2006          final CompletableFuture<Integer> g = new CompletableFuture<>();
2007 <        final Noop r = new Noop(m);
2008 <
2009 <
2010 <        (fFirst ? f : g).complete(v1);
2011 <        if (!createIncomplete)
2012 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
2013 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2014 <        if (createIncomplete) {
2015 <            checkIncomplete(h);
2016 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
2017 <        }
2018 <
2019 <        checkCompletedWithWrappedCancellationException(h);
2020 <        checkCancelled(!fFirst ? f : g);
2021 <        assertEquals(0, r.invocationCount);
2022 <        checkCompletedNormally(fFirst ? f : g, v1);
2007 >        final Noop r1 = new Noop(m);
2008 >        final Noop r2 = new Noop(m);
2009 >        final Noop r3 = new Noop(m);
2010 >
2011 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2012 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2013 >        final Callable<Boolean> complete1 = failFirst ?
2014 >            () -> fst.cancel(mayInterruptIfRunning) :
2015 >            () -> fst.complete(v1);
2016 >        final Callable<Boolean> complete2 = failFirst ?
2017 >            () -> snd.complete(v1) :
2018 >            () -> snd.cancel(mayInterruptIfRunning);
2019 >
2020 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2021 >        assertTrue(complete1.call());
2022 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2023 >        checkIncomplete(h1);
2024 >        checkIncomplete(h2);
2025 >        assertTrue(complete2.call());
2026 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2027 >
2028 >        checkCompletedWithWrappedCancellationException(h1);
2029 >        checkCompletedWithWrappedCancellationException(h2);
2030 >        checkCompletedWithWrappedCancellationException(h3);
2031 >        r1.assertNotInvoked();
2032 >        r2.assertNotInvoked();
2033 >        r3.assertNotInvoked();
2034 >        checkCompletedNormally(failFirst ? snd : fst, v1);
2035 >        checkCancelled(failFirst ? fst : snd);
2036      }}
2037  
2038      /**
# Line 1653 | Line 2046 | public class CompletableFutureTest exten
2046      {
2047          final CompletableFuture<Integer> f = new CompletableFuture<>();
2048          final CompletableFuture<Integer> g = new CompletableFuture<>();
2049 <        final FailingRunnable r = new FailingRunnable(m);
2050 <
2051 <        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r);
2052 <        if (fFirst) {
2053 <            f.complete(v1);
2054 <            g.complete(v2);
2055 <        } else {
2056 <            g.complete(v2);
2057 <            f.complete(v1);
2058 <        }
2059 <        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r);
2049 >        final FailingRunnable r1 = new FailingRunnable(m);
2050 >        final FailingRunnable r2 = new FailingRunnable(m);
2051 >        final FailingRunnable r3 = new FailingRunnable(m);
2052 >
2053 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2054 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2055 >        final Integer w1 =  fFirst ? v1 : v2;
2056 >        final Integer w2 = !fFirst ? v1 : v2;
2057 >
2058 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2059 >        assertTrue(fst.complete(w1));
2060 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2061 >        assertTrue(snd.complete(w2));
2062 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2063  
2064          checkCompletedWithWrappedCFException(h1);
2065          checkCompletedWithWrappedCFException(h2);
2066 +        checkCompletedWithWrappedCFException(h3);
2067 +        r1.assertInvoked();
2068 +        r2.assertInvoked();
2069 +        r3.assertInvoked();
2070          checkCompletedNormally(f, v1);
2071          checkCompletedNormally(g, v2);
2072      }}
# Line 1677 | Line 2077 | public class CompletableFutureTest exten
2077       */
2078      public void testApplyToEither_normalCompletion() {
2079          for (ExecutionMode m : ExecutionMode.values())
1680 –        for (boolean createIncomplete : new boolean[] { true, false })
1681 –        for (boolean fFirst : new boolean[] { true, false })
2080          for (Integer v1 : new Integer[] { 1, null })
2081          for (Integer v2 : new Integer[] { 2, null })
2082      {
2083          final CompletableFuture<Integer> f = new CompletableFuture<>();
2084          final CompletableFuture<Integer> g = new CompletableFuture<>();
2085 <        final IncFunction r = new IncFunction(m);
2085 >        final IncFunction[] rs = new IncFunction[6];
2086 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2087  
2088 <        if (!createIncomplete)
2089 <            if (fFirst) f.complete(v1); else g.complete(v2);
2090 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2091 <        if (createIncomplete) {
2092 <            checkIncomplete(h);
2093 <            assertEquals(0, r.invocationCount);
2094 <            if (fFirst) f.complete(v1); else g.complete(v2);
2095 <        }
2096 <        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
2097 <        if (!fFirst) f.complete(v1); else g.complete(v2);
2098 <
2099 <        checkCompletedNormally(f, v1);
2100 <        checkCompletedNormally(g, v2);
2101 <        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1703 <    }}
1704 <
1705 <    public void testApplyToEither_normalCompletionBothAvailable() {
1706 <        for (ExecutionMode m : ExecutionMode.values())
1707 <        for (boolean fFirst : new boolean[] { true, false })
1708 <        for (Integer v1 : new Integer[] { 1, null })
1709 <        for (Integer v2 : new Integer[] { 2, null })
1710 <    {
1711 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1712 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1713 <        final IncFunction r = new IncFunction(m);
1714 <
1715 <        if (fFirst) {
1716 <            f.complete(v1);
1717 <            g.complete(v2);
1718 <        } else {
1719 <            g.complete(v2);
1720 <            f.complete(v1);
1721 <        }
2088 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2089 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2090 >        checkIncomplete(h0);
2091 >        checkIncomplete(h1);
2092 >        rs[0].assertNotInvoked();
2093 >        rs[1].assertNotInvoked();
2094 >        f.complete(v1);
2095 >        checkCompletedNormally(h0, inc(v1));
2096 >        checkCompletedNormally(h1, inc(v1));
2097 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2098 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2099 >        checkCompletedNormally(h2, inc(v1));
2100 >        checkCompletedNormally(h3, inc(v1));
2101 >        g.complete(v2);
2102  
2103 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2103 >        // unspecified behavior - both source completions available
2104 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2105 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2106 >        rs[4].assertValue(h4.join());
2107 >        rs[5].assertValue(h5.join());
2108 >        assertTrue(Objects.equals(inc(v1), h4.join()) ||
2109 >                   Objects.equals(inc(v2), h4.join()));
2110 >        assertTrue(Objects.equals(inc(v1), h5.join()) ||
2111 >                   Objects.equals(inc(v2), h5.join()));
2112  
2113          checkCompletedNormally(f, v1);
2114          checkCompletedNormally(g, v2);
2115 <
2116 <        // unspecified behavior
2117 <        assertTrue(Objects.equals(h.join(), inc(v1)) ||
2118 <                   Objects.equals(h.join(), inc(v2)));
2119 <        assertEquals(1, r.invocationCount);
2115 >        checkCompletedNormally(h0, inc(v1));
2116 >        checkCompletedNormally(h1, inc(v1));
2117 >        checkCompletedNormally(h2, inc(v1));
2118 >        checkCompletedNormally(h3, inc(v1));
2119 >        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
2120      }}
2121  
2122      /**
2123       * applyToEither result completes exceptionally after exceptional
2124       * completion of either source
2125       */
2126 <    public void testApplyToEither_exceptionalCompletion1() {
2126 >    public void testApplyToEither_exceptionalCompletion() {
2127          for (ExecutionMode m : ExecutionMode.values())
1740 –        for (boolean createIncomplete : new boolean[] { true, false })
1741 –        for (boolean fFirst : new boolean[] { true, false })
2128          for (Integer v1 : new Integer[] { 1, null })
2129      {
2130          final CompletableFuture<Integer> f = new CompletableFuture<>();
2131          final CompletableFuture<Integer> g = new CompletableFuture<>();
2132          final CFException ex = new CFException();
2133 <        final IncFunction r = new IncFunction(m);
2133 >        final IncFunction[] rs = new IncFunction[6];
2134 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2135  
2136 <        if (!createIncomplete) (fFirst ? f : g).completeExceptionally(ex);
2137 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2138 <        if (createIncomplete) {
2139 <            checkIncomplete(h);
2140 <            assertEquals(0, r.invocationCount);
2141 <            (fFirst ? f : g).completeExceptionally(ex);
2136 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2137 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2138 >        checkIncomplete(h0);
2139 >        checkIncomplete(h1);
2140 >        rs[0].assertNotInvoked();
2141 >        rs[1].assertNotInvoked();
2142 >        f.completeExceptionally(ex);
2143 >        checkCompletedWithWrappedException(h0, ex);
2144 >        checkCompletedWithWrappedException(h1, ex);
2145 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2146 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2147 >        checkCompletedWithWrappedException(h2, ex);
2148 >        checkCompletedWithWrappedException(h3, ex);
2149 >        g.complete(v1);
2150 >
2151 >        // unspecified behavior - both source completions available
2152 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2153 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2154 >        try {
2155 >            assertEquals(inc(v1), h4.join());
2156 >            rs[4].assertValue(inc(v1));
2157 >        } catch (CompletionException ok) {
2158 >            checkCompletedWithWrappedException(h4, ex);
2159 >            rs[4].assertNotInvoked();
2160 >        }
2161 >        try {
2162 >            assertEquals(inc(v1), h5.join());
2163 >            rs[5].assertValue(inc(v1));
2164 >        } catch (CompletionException ok) {
2165 >            checkCompletedWithWrappedException(h5, ex);
2166 >            rs[5].assertNotInvoked();
2167          }
2168  
2169 <        checkCompletedWithWrappedCFException(h, ex);
2170 <        (!fFirst ? f : g).complete(v1);
2171 <
2172 <        assertEquals(0, r.invocationCount);
2173 <        checkCompletedNormally(!fFirst ? f : g, v1);
2174 <        checkCompletedWithWrappedCFException(fFirst ? f : g, ex);
2175 <        checkCompletedWithWrappedCFException(h, ex);
2169 >        checkCompletedExceptionally(f, ex);
2170 >        checkCompletedNormally(g, v1);
2171 >        checkCompletedWithWrappedException(h0, ex);
2172 >        checkCompletedWithWrappedException(h1, ex);
2173 >        checkCompletedWithWrappedException(h2, ex);
2174 >        checkCompletedWithWrappedException(h3, ex);
2175 >        checkCompletedWithWrappedException(h4, ex);
2176 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2177      }}
2178  
2179      public void testApplyToEither_exceptionalCompletion2() {
2180          for (ExecutionMode m : ExecutionMode.values())
1768 –        for (boolean reverseArgs : new boolean[] { true, false })
2181          for (boolean fFirst : new boolean[] { true, false })
2182          for (Integer v1 : new Integer[] { 1, null })
2183      {
2184          final CompletableFuture<Integer> f = new CompletableFuture<>();
2185          final CompletableFuture<Integer> g = new CompletableFuture<>();
1774 –        final IncFunction r1 = new IncFunction(m);
1775 –        final IncFunction r2 = new IncFunction(m);
2186          final CFException ex = new CFException();
2187 <        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
2188 <        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
2189 <        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
2190 <        if (fFirst) {
2191 <            f.complete(v1);
2192 <            g.completeExceptionally(ex);
2193 <        } else {
2194 <            g.completeExceptionally(ex);
2195 <            f.complete(v1);
1786 <        }
1787 <        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
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 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2193 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2194 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2195 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2196  
2197 <        // unspecified behavior
2197 >        // unspecified behavior - both source completions available
2198 >        try {
2199 >            assertEquals(inc(v1), h0.join());
2200 >            rs[0].assertValue(inc(v1));
2201 >        } catch (CompletionException ok) {
2202 >            checkCompletedWithWrappedException(h0, ex);
2203 >            rs[0].assertNotInvoked();
2204 >        }
2205          try {
2206              assertEquals(inc(v1), h1.join());
2207 <            assertEquals(1, r1.invocationCount);
2207 >            rs[1].assertValue(inc(v1));
2208          } catch (CompletionException ok) {
2209 <            checkCompletedWithWrappedCFException(h1, ex);
2210 <            assertEquals(0, r1.invocationCount);
2209 >            checkCompletedWithWrappedException(h1, ex);
2210 >            rs[1].assertNotInvoked();
2211          }
1797 –
2212          try {
2213              assertEquals(inc(v1), h2.join());
2214 <            assertEquals(1, r2.invocationCount);
2214 >            rs[2].assertValue(inc(v1));
2215          } catch (CompletionException ok) {
2216 <            checkCompletedWithWrappedCFException(h2, ex);
2217 <            assertEquals(0, r2.invocationCount);
2216 >            checkCompletedWithWrappedException(h2, ex);
2217 >            rs[2].assertNotInvoked();
2218 >        }
2219 >        try {
2220 >            assertEquals(inc(v1), h3.join());
2221 >            rs[3].assertValue(inc(v1));
2222 >        } catch (CompletionException ok) {
2223 >            checkCompletedWithWrappedException(h3, ex);
2224 >            rs[3].assertNotInvoked();
2225          }
2226  
1806 –        checkCompletedWithWrappedCFException(g, ex);
1807 –        checkCompletedNormally(f, v1);
1808 –    }}
1809 –
1810 –    /**
1811 –     * applyToEither result completes exceptionally if action does
1812 –     */
1813 –    public void testApplyToEither_actionFailed1() {
1814 –        for (ExecutionMode m : ExecutionMode.values())
1815 –        for (Integer v1 : new Integer[] { 1, null })
1816 –        for (Integer v2 : new Integer[] { 2, null })
1817 –    {
1818 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1819 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1820 –        final FailingFunction r = new FailingFunction(m);
1821 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1822 –
1823 –        f.complete(v1);
1824 –        checkCompletedWithWrappedCFException(h);
1825 –        g.complete(v2);
1826 –        checkCompletedNormally(f, v1);
1827 –        checkCompletedNormally(g, v2);
1828 –    }}
1829 –
1830 –    public void testApplyToEither_actionFailed2() {
1831 –        for (ExecutionMode m : ExecutionMode.values())
1832 –        for (Integer v1 : new Integer[] { 1, null })
1833 –        for (Integer v2 : new Integer[] { 2, null })
1834 –    {
1835 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1836 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1837 –        final FailingFunction r = new FailingFunction(m);
1838 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1839 –
1840 –        g.complete(v2);
1841 –        checkCompletedWithWrappedCFException(h);
1842 –        f.complete(v1);
2227          checkCompletedNormally(f, v1);
2228 <        checkCompletedNormally(g, v2);
2228 >        checkCompletedExceptionally(g, ex);
2229      }}
2230  
2231      /**
2232       * applyToEither result completes exceptionally if either source cancelled
2233       */
2234 <    public void testApplyToEither_sourceCancelled1() {
2234 >    public void testApplyToEither_sourceCancelled() {
2235          for (ExecutionMode m : ExecutionMode.values())
2236          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1853 –        for (boolean createIncomplete : new boolean[] { true, false })
1854 –        for (boolean fFirst : new boolean[] { true, false })
2237          for (Integer v1 : new Integer[] { 1, null })
2238      {
2239          final CompletableFuture<Integer> f = new CompletableFuture<>();
2240          final CompletableFuture<Integer> g = new CompletableFuture<>();
2241 <        final IncFunction r = new IncFunction(m);
2241 >        final IncFunction[] rs = new IncFunction[6];
2242 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2243  
2244 <        if (!createIncomplete) assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
2245 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2246 <        if (createIncomplete) {
2247 <            checkIncomplete(h);
2248 <            assertEquals(0, r.invocationCount);
2249 <            assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
2244 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2245 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2246 >        checkIncomplete(h0);
2247 >        checkIncomplete(h1);
2248 >        rs[0].assertNotInvoked();
2249 >        rs[1].assertNotInvoked();
2250 >        f.cancel(mayInterruptIfRunning);
2251 >        checkCompletedWithWrappedCancellationException(h0);
2252 >        checkCompletedWithWrappedCancellationException(h1);
2253 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2254 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2255 >        checkCompletedWithWrappedCancellationException(h2);
2256 >        checkCompletedWithWrappedCancellationException(h3);
2257 >        g.complete(v1);
2258 >
2259 >        // unspecified behavior - both source completions available
2260 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2261 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2262 >        try {
2263 >            assertEquals(inc(v1), h4.join());
2264 >            rs[4].assertValue(inc(v1));
2265 >        } catch (CompletionException ok) {
2266 >            checkCompletedWithWrappedCancellationException(h4);
2267 >            rs[4].assertNotInvoked();
2268 >        }
2269 >        try {
2270 >            assertEquals(inc(v1), h5.join());
2271 >            rs[5].assertValue(inc(v1));
2272 >        } catch (CompletionException ok) {
2273 >            checkCompletedWithWrappedCancellationException(h5);
2274 >            rs[5].assertNotInvoked();
2275          }
2276  
2277 <        checkCompletedWithWrappedCancellationException(h);
2278 <        (!fFirst ? f : g).complete(v1);
2279 <
2280 <        assertEquals(0, r.invocationCount);
2281 <        checkCompletedNormally(!fFirst ? f : g, v1);
2282 <        checkCancelled(fFirst ? f : g);
2283 <        checkCompletedWithWrappedCancellationException(h);
2277 >        checkCancelled(f);
2278 >        checkCompletedNormally(g, v1);
2279 >        checkCompletedWithWrappedCancellationException(h0);
2280 >        checkCompletedWithWrappedCancellationException(h1);
2281 >        checkCompletedWithWrappedCancellationException(h2);
2282 >        checkCompletedWithWrappedCancellationException(h3);
2283 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2284      }}
2285  
2286      public void testApplyToEither_sourceCancelled2() {
2287          for (ExecutionMode m : ExecutionMode.values())
2288          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1881 –        for (boolean reverseArgs : new boolean[] { true, false })
2289          for (boolean fFirst : new boolean[] { true, false })
2290          for (Integer v1 : new Integer[] { 1, null })
2291      {
2292          final CompletableFuture<Integer> f = new CompletableFuture<>();
2293          final CompletableFuture<Integer> g = new CompletableFuture<>();
2294 <        final IncFunction r1 = new IncFunction(m);
2295 <        final IncFunction r2 = new IncFunction(m);
1889 <        final CFException ex = new CFException();
1890 <        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1891 <        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
2294 >        final IncFunction[] rs = new IncFunction[6];
2295 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2296  
2297 <        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
2298 <        if (fFirst) {
2299 <            f.complete(v1);
2300 <            assertTrue(g.cancel(mayInterruptIfRunning));
2301 <        } else {
2302 <            assertTrue(g.cancel(mayInterruptIfRunning));
1899 <            f.complete(v1);
1900 <        }
1901 <        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
2297 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2298 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2299 >        assertTrue(fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2300 >        assertTrue(!fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2301 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2302 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2303  
2304 <        // unspecified behavior
2304 >        // unspecified behavior - both source completions available
2305 >        try {
2306 >            assertEquals(inc(v1), h0.join());
2307 >            rs[0].assertValue(inc(v1));
2308 >        } catch (CompletionException ok) {
2309 >            checkCompletedWithWrappedCancellationException(h0);
2310 >            rs[0].assertNotInvoked();
2311 >        }
2312          try {
2313              assertEquals(inc(v1), h1.join());
2314 <            assertEquals(1, r1.invocationCount);
2314 >            rs[1].assertValue(inc(v1));
2315          } catch (CompletionException ok) {
2316              checkCompletedWithWrappedCancellationException(h1);
2317 <            assertEquals(0, r1.invocationCount);
2317 >            rs[1].assertNotInvoked();
2318          }
1911 –
2319          try {
2320              assertEquals(inc(v1), h2.join());
2321 <            assertEquals(1, r2.invocationCount);
2321 >            rs[2].assertValue(inc(v1));
2322          } catch (CompletionException ok) {
2323              checkCompletedWithWrappedCancellationException(h2);
2324 <            assertEquals(0, r2.invocationCount);
2324 >            rs[2].assertNotInvoked();
2325 >        }
2326 >        try {
2327 >            assertEquals(inc(v1), h3.join());
2328 >            rs[3].assertValue(inc(v1));
2329 >        } catch (CompletionException ok) {
2330 >            checkCompletedWithWrappedCancellationException(h3);
2331 >            rs[3].assertNotInvoked();
2332          }
2333  
1920 –        checkCancelled(g);
2334          checkCompletedNormally(f, v1);
2335 +        checkCancelled(g);
2336      }}
2337  
2338      /**
2339 <     * acceptEither result completes normally after normal completion
1926 <     * of either source
2339 >     * applyToEither result completes exceptionally if action does
2340       */
2341 <    public void testAcceptEither_normalCompletion1() {
2341 >    public void testApplyToEither_actionFailed() {
2342          for (ExecutionMode m : ExecutionMode.values())
2343          for (Integer v1 : new Integer[] { 1, null })
2344          for (Integer v2 : new Integer[] { 2, null })
2345      {
2346          final CompletableFuture<Integer> f = new CompletableFuture<>();
2347          final CompletableFuture<Integer> g = new CompletableFuture<>();
2348 <        final IncAction r = new IncAction();
2349 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2348 >        final FailingFunction[] rs = new FailingFunction[6];
2349 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(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          f.complete(v1);
2354 <        checkCompletedNormally(h, null);
2355 <        assertEquals(inc(v1), r.value);
2356 <        g.complete(v2);
2357 <
2358 <        checkCompletedNormally(f, v1);
2359 <        checkCompletedNormally(g, v2);
2360 <        checkCompletedNormally(h, null);
1946 <    }}
1947 <
1948 <    public void testAcceptEither_normalCompletion2() {
1949 <        for (ExecutionMode m : ExecutionMode.values())
1950 <        for (Integer v1 : new Integer[] { 1, null })
1951 <        for (Integer v2 : new Integer[] { 2, null })
1952 <    {
1953 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1954 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1955 <        final IncAction r = new IncAction();
1956 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2354 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2355 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2356 >        checkCompletedWithWrappedCFException(h0);
2357 >        checkCompletedWithWrappedCFException(h1);
2358 >        checkCompletedWithWrappedCFException(h2);
2359 >        checkCompletedWithWrappedCFException(h3);
2360 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2361  
2362          g.complete(v2);
2363 <        checkCompletedNormally(h, null);
2364 <        assertEquals(inc(v2), r.value);
2365 <        f.complete(v1);
2363 >
2364 >        // unspecified behavior - both source completions available
2365 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
2366 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2367 >
2368 >        checkCompletedWithWrappedCFException(h4);
2369 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2370 >                   Objects.equals(v2, rs[4].value));
2371 >        checkCompletedWithWrappedCFException(h5);
2372 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2373 >                   Objects.equals(v2, rs[5].value));
2374  
2375          checkCompletedNormally(f, v1);
2376          checkCompletedNormally(g, v2);
1965 –        checkCompletedNormally(h, null);
2377      }}
2378  
2379 <    public void testAcceptEither_normalCompletion3() {
2379 >    /**
2380 >     * acceptEither result completes normally after normal completion
2381 >     * of either source
2382 >     */
2383 >    public void testAcceptEither_normalCompletion() {
2384          for (ExecutionMode m : ExecutionMode.values())
2385          for (Integer v1 : new Integer[] { 1, null })
2386          for (Integer v2 : new Integer[] { 2, null })
2387      {
2388          final CompletableFuture<Integer> f = new CompletableFuture<>();
2389          final CompletableFuture<Integer> g = new CompletableFuture<>();
2390 <        final IncAction r = new IncAction();
2390 >        final NoopConsumer[] rs = new NoopConsumer[6];
2391 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2392  
2393 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2394 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2395 +        checkIncomplete(h0);
2396 +        checkIncomplete(h1);
2397 +        rs[0].assertNotInvoked();
2398 +        rs[1].assertNotInvoked();
2399          f.complete(v1);
2400 +        checkCompletedNormally(h0, null);
2401 +        checkCompletedNormally(h1, null);
2402 +        rs[0].assertValue(v1);
2403 +        rs[1].assertValue(v1);
2404 +        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2405 +        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2406 +        checkCompletedNormally(h2, null);
2407 +        checkCompletedNormally(h3, null);
2408 +        rs[2].assertValue(v1);
2409 +        rs[3].assertValue(v1);
2410          g.complete(v2);
1979 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2411  
2412 <        checkCompletedNormally(h, null);
2412 >        // unspecified behavior - both source completions available
2413 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2414 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2415 >        checkCompletedNormally(h4, null);
2416 >        checkCompletedNormally(h5, null);
2417 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2418 >                   Objects.equals(v2, rs[4].value));
2419 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2420 >                   Objects.equals(v2, rs[5].value));
2421 >
2422          checkCompletedNormally(f, v1);
2423          checkCompletedNormally(g, v2);
2424 <
2425 <        // unspecified behavior
2426 <        assertTrue(Objects.equals(r.value, inc(v1)) ||
2427 <                   Objects.equals(r.value, inc(v2)));
2424 >        checkCompletedNormally(h0, null);
2425 >        checkCompletedNormally(h1, null);
2426 >        checkCompletedNormally(h2, null);
2427 >        checkCompletedNormally(h3, null);
2428 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2429      }}
2430  
2431      /**
2432       * acceptEither result completes exceptionally after exceptional
2433       * completion of either source
2434       */
2435 <    public void testAcceptEither_exceptionalCompletion1() {
2435 >    public void testAcceptEither_exceptionalCompletion() {
2436          for (ExecutionMode m : ExecutionMode.values())
2437          for (Integer v1 : new Integer[] { 1, null })
2438      {
2439          final CompletableFuture<Integer> f = new CompletableFuture<>();
2440          final CompletableFuture<Integer> g = new CompletableFuture<>();
2000 –        final IncAction r = new IncAction();
2001 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2441          final CFException ex = new CFException();
2442 +        final NoopConsumer[] rs = new NoopConsumer[6];
2443 +        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2444  
2445 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2446 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2447 +        checkIncomplete(h0);
2448 +        checkIncomplete(h1);
2449 +        rs[0].assertNotInvoked();
2450 +        rs[1].assertNotInvoked();
2451          f.completeExceptionally(ex);
2452 <        checkCompletedWithWrappedCFException(h, ex);
2452 >        checkCompletedWithWrappedException(h0, ex);
2453 >        checkCompletedWithWrappedException(h1, ex);
2454 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2455 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2456 >        checkCompletedWithWrappedException(h2, ex);
2457 >        checkCompletedWithWrappedException(h3, ex);
2458 >
2459          g.complete(v1);
2460  
2461 <        assertEquals(0, r.invocationCount);
2461 >        // unspecified behavior - both source completions available
2462 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2463 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2464 >        try {
2465 >            assertNull(h4.join());
2466 >            rs[4].assertValue(v1);
2467 >        } catch (CompletionException ok) {
2468 >            checkCompletedWithWrappedException(h4, ex);
2469 >            rs[4].assertNotInvoked();
2470 >        }
2471 >        try {
2472 >            assertNull(h5.join());
2473 >            rs[5].assertValue(v1);
2474 >        } catch (CompletionException ok) {
2475 >            checkCompletedWithWrappedException(h5, ex);
2476 >            rs[5].assertNotInvoked();
2477 >        }
2478 >
2479 >        checkCompletedExceptionally(f, ex);
2480          checkCompletedNormally(g, v1);
2481 <        checkCompletedWithWrappedCFException(f, ex);
2482 <        checkCompletedWithWrappedCFException(h, ex);
2481 >        checkCompletedWithWrappedException(h0, ex);
2482 >        checkCompletedWithWrappedException(h1, ex);
2483 >        checkCompletedWithWrappedException(h2, ex);
2484 >        checkCompletedWithWrappedException(h3, ex);
2485 >        checkCompletedWithWrappedException(h4, ex);
2486 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2487      }}
2488  
2489      public void testAcceptEither_exceptionalCompletion2() {
2490          for (ExecutionMode m : ExecutionMode.values())
2491 +        for (boolean fFirst : new boolean[] { true, false })
2492          for (Integer v1 : new Integer[] { 1, null })
2493      {
2494          final CompletableFuture<Integer> f = new CompletableFuture<>();
2495          final CompletableFuture<Integer> g = new CompletableFuture<>();
2020 –        final IncAction r = new IncAction();
2021 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2022 –        final CFException ex = new CFException();
2023 –
2024 –        g.completeExceptionally(ex);
2025 –        checkCompletedWithWrappedCFException(h, ex);
2026 –        f.complete(v1);
2027 –
2028 –        assertEquals(0, r.invocationCount);
2029 –        checkCompletedNormally(f, v1);
2030 –        checkCompletedWithWrappedCFException(g, ex);
2031 –        checkCompletedWithWrappedCFException(h, ex);
2032 –    }}
2033 –
2034 –    public void testAcceptEither_exceptionalCompletion3() {
2035 –        for (ExecutionMode m : ExecutionMode.values())
2036 –        for (Integer v1 : new Integer[] { 1, null })
2037 –    {
2038 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2039 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2040 –        final IncAction r = new IncAction();
2496          final CFException ex = new CFException();
2497 +        final NoopConsumer[] rs = new NoopConsumer[6];
2498 +        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2499  
2500 <        g.completeExceptionally(ex);
2501 <        f.complete(v1);
2502 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2500 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2501 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2502 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2503 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2504 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2505 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2506  
2507 <        // unspecified behavior
2048 <        Integer v;
2507 >        // unspecified behavior - both source completions available
2508          try {
2509 <            assertNull(h.join());
2510 <            assertEquals(1, r.invocationCount);
2052 <            assertEquals(inc(v1), r.value);
2509 >            assertEquals(null, h0.join());
2510 >            rs[0].assertValue(v1);
2511          } catch (CompletionException ok) {
2512 <            checkCompletedWithWrappedCFException(h, ex);
2513 <            assertEquals(0, r.invocationCount);
2512 >            checkCompletedWithWrappedException(h0, ex);
2513 >            rs[0].assertNotInvoked();
2514          }
2057 –
2058 –        checkCompletedWithWrappedCFException(g, ex);
2059 –        checkCompletedNormally(f, v1);
2060 –    }}
2061 –
2062 –    public void testAcceptEither_exceptionalCompletion4() {
2063 –        for (ExecutionMode m : ExecutionMode.values())
2064 –        for (Integer v1 : new Integer[] { 1, null })
2065 –    {
2066 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2067 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2068 –        final IncAction r = new IncAction();
2069 –        final CFException ex = new CFException();
2070 –
2071 –        f.completeExceptionally(ex);
2072 –        g.complete(v1);
2073 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2074 –
2075 –        // unspecified behavior
2076 –        Integer v;
2515          try {
2516 <            assertNull(h.join());
2517 <            assertEquals(1, r.invocationCount);
2080 <            assertEquals(inc(v1), r.value);
2516 >            assertEquals(null, h1.join());
2517 >            rs[1].assertValue(v1);
2518          } catch (CompletionException ok) {
2519 <            checkCompletedWithWrappedCFException(h, ex);
2520 <            assertEquals(0, r.invocationCount);
2519 >            checkCompletedWithWrappedException(h1, ex);
2520 >            rs[1].assertNotInvoked();
2521 >        }
2522 >        try {
2523 >            assertEquals(null, h2.join());
2524 >            rs[2].assertValue(v1);
2525 >        } catch (CompletionException ok) {
2526 >            checkCompletedWithWrappedException(h2, ex);
2527 >            rs[2].assertNotInvoked();
2528 >        }
2529 >        try {
2530 >            assertEquals(null, h3.join());
2531 >            rs[3].assertValue(v1);
2532 >        } catch (CompletionException ok) {
2533 >            checkCompletedWithWrappedException(h3, ex);
2534 >            rs[3].assertNotInvoked();
2535          }
2536  
2086 –        checkCompletedWithWrappedCFException(f, ex);
2087 –        checkCompletedNormally(g, v1);
2088 –    }}
2089 –
2090 –    /**
2091 –     * acceptEither result completes exceptionally if action does
2092 –     */
2093 –    public void testAcceptEither_actionFailed1() {
2094 –        for (ExecutionMode m : ExecutionMode.values())
2095 –        for (Integer v1 : new Integer[] { 1, null })
2096 –        for (Integer v2 : new Integer[] { 2, null })
2097 –    {
2098 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2099 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2100 –        final FailingConsumer r = new FailingConsumer(m);
2101 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2102 –
2103 –        f.complete(v1);
2104 –        checkCompletedWithWrappedCFException(h);
2105 –        g.complete(v2);
2106 –        checkCompletedNormally(f, v1);
2107 –        checkCompletedNormally(g, v2);
2108 –    }}
2109 –
2110 –    public void testAcceptEither_actionFailed2() {
2111 –        for (ExecutionMode m : ExecutionMode.values())
2112 –        for (Integer v1 : new Integer[] { 1, null })
2113 –        for (Integer v2 : new Integer[] { 2, null })
2114 –    {
2115 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2116 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2117 –        final FailingConsumer r = new FailingConsumer(m);
2118 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2119 –
2120 –        g.complete(v2);
2121 –        checkCompletedWithWrappedCFException(h);
2122 –        f.complete(v1);
2537          checkCompletedNormally(f, v1);
2538 <        checkCompletedNormally(g, v2);
2538 >        checkCompletedExceptionally(g, ex);
2539      }}
2540  
2541      /**
2542       * acceptEither result completes exceptionally if either source cancelled
2543       */
2544 <    public void testAcceptEither_sourceCancelled1() {
2544 >    public void testAcceptEither_sourceCancelled() {
2545          for (ExecutionMode m : ExecutionMode.values())
2546          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2547          for (Integer v1 : new Integer[] { 1, null })
2548      {
2549          final CompletableFuture<Integer> f = new CompletableFuture<>();
2550          final CompletableFuture<Integer> g = new CompletableFuture<>();
2551 <        final IncAction r = new IncAction();
2552 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2139 <
2140 <        assertTrue(f.cancel(mayInterruptIfRunning));
2141 <        checkCompletedWithWrappedCancellationException(h);
2142 <        g.complete(v1);
2551 >        final NoopConsumer[] rs = new NoopConsumer[6];
2552 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2553  
2554 <        checkCancelled(f);
2555 <        assertEquals(0, r.invocationCount);
2556 <        checkCompletedNormally(g, v1);
2557 <        checkCompletedWithWrappedCancellationException(h);
2558 <    }}
2554 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2555 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2556 >        checkIncomplete(h0);
2557 >        checkIncomplete(h1);
2558 >        rs[0].assertNotInvoked();
2559 >        rs[1].assertNotInvoked();
2560 >        f.cancel(mayInterruptIfRunning);
2561 >        checkCompletedWithWrappedCancellationException(h0);
2562 >        checkCompletedWithWrappedCancellationException(h1);
2563 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2564 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2565 >        checkCompletedWithWrappedCancellationException(h2);
2566 >        checkCompletedWithWrappedCancellationException(h3);
2567  
2568 <    public void testAcceptEither_sourceCancelled2() {
2151 <        for (ExecutionMode m : ExecutionMode.values())
2152 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2153 <        for (Integer v1 : new Integer[] { 1, null })
2154 <    {
2155 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2156 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2157 <        final IncAction r = new IncAction();
2158 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2159 <
2160 <        assertTrue(g.cancel(mayInterruptIfRunning));
2161 <        checkCompletedWithWrappedCancellationException(h);
2162 <        f.complete(v1);
2163 <
2164 <        checkCancelled(g);
2165 <        assertEquals(0, r.invocationCount);
2166 <        checkCompletedNormally(f, v1);
2167 <        checkCompletedWithWrappedCancellationException(h);
2168 <    }}
2169 <
2170 <    public void testAcceptEither_sourceCancelled3() {
2171 <        for (ExecutionMode m : ExecutionMode.values())
2172 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2173 <        for (Integer v1 : new Integer[] { 1, null })
2174 <    {
2175 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2176 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2177 <        final IncAction r = new IncAction();
2178 <
2179 <        assertTrue(g.cancel(mayInterruptIfRunning));
2180 <        f.complete(v1);
2181 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2568 >        g.complete(v1);
2569  
2570 <        // unspecified behavior
2571 <        Integer v;
2570 >        // unspecified behavior - both source completions available
2571 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2572 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2573          try {
2574 <            assertNull(h.join());
2575 <            assertEquals(1, r.invocationCount);
2188 <            assertEquals(inc(v1), r.value);
2574 >            assertNull(h4.join());
2575 >            rs[4].assertValue(v1);
2576          } catch (CompletionException ok) {
2577 <            checkCompletedWithWrappedCancellationException(h);
2578 <            assertEquals(0, r.invocationCount);
2577 >            checkCompletedWithWrappedCancellationException(h4);
2578 >            rs[4].assertNotInvoked();
2579          }
2193 –
2194 –        checkCancelled(g);
2195 –        checkCompletedNormally(f, v1);
2196 –    }}
2197 –
2198 –    public void testAcceptEither_sourceCancelled4() {
2199 –        for (ExecutionMode m : ExecutionMode.values())
2200 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2201 –        for (Integer v1 : new Integer[] { 1, null })
2202 –    {
2203 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2204 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2205 –        final IncAction r = new IncAction();
2206 –
2207 –        assertTrue(f.cancel(mayInterruptIfRunning));
2208 –        g.complete(v1);
2209 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2210 –
2211 –        // unspecified behavior
2212 –        Integer v;
2580          try {
2581 <            assertNull(h.join());
2582 <            assertEquals(1, r.invocationCount);
2216 <            assertEquals(inc(v1), r.value);
2581 >            assertNull(h5.join());
2582 >            rs[5].assertValue(v1);
2583          } catch (CompletionException ok) {
2584 <            checkCompletedWithWrappedCancellationException(h);
2585 <            assertEquals(0, r.invocationCount);
2584 >            checkCompletedWithWrappedCancellationException(h5);
2585 >            rs[5].assertNotInvoked();
2586          }
2587  
2588          checkCancelled(f);
2589          checkCompletedNormally(g, v1);
2590 +        checkCompletedWithWrappedCancellationException(h0);
2591 +        checkCompletedWithWrappedCancellationException(h1);
2592 +        checkCompletedWithWrappedCancellationException(h2);
2593 +        checkCompletedWithWrappedCancellationException(h3);
2594 +        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2595      }}
2596  
2597      /**
2598 <     * runAfterEither result completes normally after normal completion
2228 <     * of either source
2598 >     * acceptEither result completes exceptionally if action does
2599       */
2600 <    public void testRunAfterEither_normalCompletion1() {
2600 >    public void testAcceptEither_actionFailed() {
2601          for (ExecutionMode m : ExecutionMode.values())
2602          for (Integer v1 : new Integer[] { 1, null })
2603          for (Integer v2 : new Integer[] { 2, null })
2604      {
2605          final CompletableFuture<Integer> f = new CompletableFuture<>();
2606          final CompletableFuture<Integer> g = new CompletableFuture<>();
2607 <        final Noop r = new Noop(m);
2608 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2607 >        final FailingConsumer[] rs = new FailingConsumer[6];
2608 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
2609  
2610 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2611 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2612          f.complete(v1);
2613 <        checkCompletedNormally(h, null);
2614 <        assertEquals(1, r.invocationCount);
2613 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2614 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2615 >        checkCompletedWithWrappedCFException(h0);
2616 >        checkCompletedWithWrappedCFException(h1);
2617 >        checkCompletedWithWrappedCFException(h2);
2618 >        checkCompletedWithWrappedCFException(h3);
2619 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2620 >
2621          g.complete(v2);
2622  
2623 +        // unspecified behavior - both source completions available
2624 +        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2625 +        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2626 +
2627 +        checkCompletedWithWrappedCFException(h4);
2628 +        assertTrue(Objects.equals(v1, rs[4].value) ||
2629 +                   Objects.equals(v2, rs[4].value));
2630 +        checkCompletedWithWrappedCFException(h5);
2631 +        assertTrue(Objects.equals(v1, rs[5].value) ||
2632 +                   Objects.equals(v2, rs[5].value));
2633 +
2634          checkCompletedNormally(f, v1);
2635          checkCompletedNormally(g, v2);
2247 –        checkCompletedNormally(h, null);
2248 –        assertEquals(1, r.invocationCount);
2636      }}
2637  
2638 <    public void testRunAfterEither_normalCompletion2() {
2638 >    /**
2639 >     * runAfterEither result completes normally after normal completion
2640 >     * of either source
2641 >     */
2642 >    public void testRunAfterEither_normalCompletion() {
2643          for (ExecutionMode m : ExecutionMode.values())
2644          for (Integer v1 : new Integer[] { 1, null })
2645          for (Integer v2 : new Integer[] { 2, null })
2646      {
2647          final CompletableFuture<Integer> f = new CompletableFuture<>();
2648          final CompletableFuture<Integer> g = new CompletableFuture<>();
2649 <        final Noop r = new Noop(m);
2650 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2649 >        final Noop[] rs = new Noop[6];
2650 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2651  
2652 <        g.complete(v2);
2653 <        checkCompletedNormally(h, null);
2654 <        assertEquals(1, r.invocationCount);
2652 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2653 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2654 >        checkIncomplete(h0);
2655 >        checkIncomplete(h1);
2656 >        rs[0].assertNotInvoked();
2657 >        rs[1].assertNotInvoked();
2658          f.complete(v1);
2659 +        checkCompletedNormally(h0, null);
2660 +        checkCompletedNormally(h1, null);
2661 +        rs[0].assertInvoked();
2662 +        rs[1].assertInvoked();
2663 +        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2664 +        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2665 +        checkCompletedNormally(h2, null);
2666 +        checkCompletedNormally(h3, null);
2667 +        rs[2].assertInvoked();
2668 +        rs[3].assertInvoked();
2669  
2266 –        checkCompletedNormally(f, v1);
2267 –        checkCompletedNormally(g, v2);
2268 –        checkCompletedNormally(h, null);
2269 –        assertEquals(1, r.invocationCount);
2270 –        }}
2271 –
2272 –    public void testRunAfterEither_normalCompletion3() {
2273 –        for (ExecutionMode m : ExecutionMode.values())
2274 –        for (Integer v1 : new Integer[] { 1, null })
2275 –        for (Integer v2 : new Integer[] { 2, null })
2276 –    {
2277 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2278 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2279 –        final Noop r = new Noop(m);
2280 –
2281 –        f.complete(v1);
2670          g.complete(v2);
2283 –        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2671  
2672 <        checkCompletedNormally(h, null);
2672 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2673 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2674 >
2675          checkCompletedNormally(f, v1);
2676          checkCompletedNormally(g, v2);
2677 <        assertEquals(1, r.invocationCount);
2677 >        checkCompletedNormally(h0, null);
2678 >        checkCompletedNormally(h1, null);
2679 >        checkCompletedNormally(h2, null);
2680 >        checkCompletedNormally(h3, null);
2681 >        checkCompletedNormally(h4, null);
2682 >        checkCompletedNormally(h5, null);
2683 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2684      }}
2685  
2686      /**
2687       * runAfterEither result completes exceptionally after exceptional
2688       * completion of either source
2689       */
2690 <    public void testRunAfterEither_exceptionalCompletion1() {
2690 >    public void testRunAfterEither_exceptionalCompletion() {
2691          for (ExecutionMode m : ExecutionMode.values())
2692          for (Integer v1 : new Integer[] { 1, null })
2693      {
2694          final CompletableFuture<Integer> f = new CompletableFuture<>();
2695          final CompletableFuture<Integer> g = new CompletableFuture<>();
2301 –        final Noop r = new Noop(m);
2302 –        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2696          final CFException ex = new CFException();
2697 +        final Noop[] rs = new Noop[6];
2698 +        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2699  
2700 <        f.completeExceptionally(ex);
2701 <        checkCompletedWithWrappedCFException(h, ex);
2702 <        g.complete(v1);
2703 <
2704 <        assertEquals(0, r.invocationCount);
2705 <        checkCompletedNormally(g, v1);
2706 <        checkCompletedWithWrappedCFException(f, ex);
2707 <        checkCompletedWithWrappedCFException(h, ex);
2708 <    }}
2700 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2701 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2702 >        checkIncomplete(h0);
2703 >        checkIncomplete(h1);
2704 >        rs[0].assertNotInvoked();
2705 >        rs[1].assertNotInvoked();
2706 >        assertTrue(f.completeExceptionally(ex));
2707 >        checkCompletedWithWrappedException(h0, ex);
2708 >        checkCompletedWithWrappedException(h1, ex);
2709 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2710 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2711 >        checkCompletedWithWrappedException(h2, ex);
2712 >        checkCompletedWithWrappedException(h3, ex);
2713  
2714 <    public void testRunAfterEither_exceptionalCompletion2() {
2316 <        for (ExecutionMode m : ExecutionMode.values())
2317 <        for (Integer v1 : new Integer[] { 1, null })
2318 <    {
2319 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2320 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2321 <        final Noop r = new Noop(m);
2322 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2323 <        final CFException ex = new CFException();
2324 <
2325 <        g.completeExceptionally(ex);
2326 <        checkCompletedWithWrappedCFException(h, ex);
2327 <        f.complete(v1);
2714 >        assertTrue(g.complete(v1));
2715  
2716 <        assertEquals(0, r.invocationCount);
2717 <        checkCompletedNormally(f, v1);
2718 <        checkCompletedWithWrappedCFException(g, ex);
2332 <        checkCompletedWithWrappedCFException(h, ex);
2333 <    }}
2334 <
2335 <    public void testRunAfterEither_exceptionalCompletion3() {
2336 <        for (ExecutionMode m : ExecutionMode.values())
2337 <        for (Integer v1 : new Integer[] { 1, null })
2338 <    {
2339 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2340 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2341 <        final Noop r = new Noop(m);
2342 <        final CFException ex = new CFException();
2343 <
2344 <        g.completeExceptionally(ex);
2345 <        f.complete(v1);
2346 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2347 <
2348 <        // unspecified behavior
2349 <        Integer v;
2716 >        // unspecified behavior - both source completions available
2717 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2718 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2719          try {
2720 <            assertNull(h.join());
2721 <            assertEquals(1, r.invocationCount);
2720 >            assertNull(h4.join());
2721 >            rs[4].assertInvoked();
2722          } catch (CompletionException ok) {
2723 <            checkCompletedWithWrappedCFException(h, ex);
2724 <            assertEquals(0, r.invocationCount);
2723 >            checkCompletedWithWrappedException(h4, ex);
2724 >            rs[4].assertNotInvoked();
2725          }
2357 –
2358 –        checkCompletedWithWrappedCFException(g, ex);
2359 –        checkCompletedNormally(f, v1);
2360 –    }}
2361 –
2362 –    public void testRunAfterEither_exceptionalCompletion4() {
2363 –        for (ExecutionMode m : ExecutionMode.values())
2364 –        for (Integer v1 : new Integer[] { 1, null })
2365 –    {
2366 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2367 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2368 –        final Noop r = new Noop(m);
2369 –        final CFException ex = new CFException();
2370 –
2371 –        f.completeExceptionally(ex);
2372 –        g.complete(v1);
2373 –        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2374 –
2375 –        // unspecified behavior
2376 –        Integer v;
2726          try {
2727 <            assertNull(h.join());
2728 <            assertEquals(1, r.invocationCount);
2727 >            assertNull(h5.join());
2728 >            rs[5].assertInvoked();
2729          } catch (CompletionException ok) {
2730 <            checkCompletedWithWrappedCFException(h, ex);
2731 <            assertEquals(0, r.invocationCount);
2730 >            checkCompletedWithWrappedException(h5, ex);
2731 >            rs[5].assertNotInvoked();
2732          }
2733  
2734 <        checkCompletedWithWrappedCFException(f, ex);
2734 >        checkCompletedExceptionally(f, ex);
2735          checkCompletedNormally(g, v1);
2736 +        checkCompletedWithWrappedException(h0, ex);
2737 +        checkCompletedWithWrappedException(h1, ex);
2738 +        checkCompletedWithWrappedException(h2, ex);
2739 +        checkCompletedWithWrappedException(h3, ex);
2740 +        checkCompletedWithWrappedException(h4, ex);
2741 +        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2742      }}
2743  
2744 <    /**
2390 <     * runAfterEither result completes exceptionally if action does
2391 <     */
2392 <    public void testRunAfterEither_actionFailed1() {
2744 >    public void testRunAfterEither_exceptionalCompletion2() {
2745          for (ExecutionMode m : ExecutionMode.values())
2746 +        for (boolean fFirst : new boolean[] { true, false })
2747          for (Integer v1 : new Integer[] { 1, null })
2395 –        for (Integer v2 : new Integer[] { 2, null })
2748      {
2749          final CompletableFuture<Integer> f = new CompletableFuture<>();
2750          final CompletableFuture<Integer> g = new CompletableFuture<>();
2751 <        final FailingRunnable r = new FailingRunnable(m);
2752 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2751 >        final CFException ex = new CFException();
2752 >        final Noop[] rs = new Noop[6];
2753 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2754  
2755 <        f.complete(v1);
2756 <        checkCompletedWithWrappedCFException(h);
2757 <        g.complete(v2);
2758 <        checkCompletedNormally(f, v1);
2759 <        checkCompletedNormally(g, v2);
2760 <    }}
2755 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2756 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2757 >        assertTrue( fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2758 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2759 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2760 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2761  
2762 <    public void testRunAfterEither_actionFailed2() {
2763 <        for (ExecutionMode m : ExecutionMode.values())
2764 <        for (Integer v1 : new Integer[] { 1, null })
2765 <        for (Integer v2 : new Integer[] { 2, null })
2766 <    {
2767 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2768 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2769 <        final FailingRunnable r = new FailingRunnable(m);
2770 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2762 >        // unspecified behavior - both source completions available
2763 >        try {
2764 >            assertEquals(null, h0.join());
2765 >            rs[0].assertInvoked();
2766 >        } catch (CompletionException ok) {
2767 >            checkCompletedWithWrappedException(h0, ex);
2768 >            rs[0].assertNotInvoked();
2769 >        }
2770 >        try {
2771 >            assertEquals(null, h1.join());
2772 >            rs[1].assertInvoked();
2773 >        } catch (CompletionException ok) {
2774 >            checkCompletedWithWrappedException(h1, ex);
2775 >            rs[1].assertNotInvoked();
2776 >        }
2777 >        try {
2778 >            assertEquals(null, h2.join());
2779 >            rs[2].assertInvoked();
2780 >        } catch (CompletionException ok) {
2781 >            checkCompletedWithWrappedException(h2, ex);
2782 >            rs[2].assertNotInvoked();
2783 >        }
2784 >        try {
2785 >            assertEquals(null, h3.join());
2786 >            rs[3].assertInvoked();
2787 >        } catch (CompletionException ok) {
2788 >            checkCompletedWithWrappedException(h3, ex);
2789 >            rs[3].assertNotInvoked();
2790 >        }
2791  
2419 –        g.complete(v2);
2420 –        checkCompletedWithWrappedCFException(h);
2421 –        f.complete(v1);
2792          checkCompletedNormally(f, v1);
2793 <        checkCompletedNormally(g, v2);
2793 >        checkCompletedExceptionally(g, ex);
2794      }}
2795  
2796      /**
2797       * runAfterEither result completes exceptionally if either source cancelled
2798       */
2799 <    public void testRunAfterEither_sourceCancelled1() {
2799 >    public void testRunAfterEither_sourceCancelled() {
2800          for (ExecutionMode m : ExecutionMode.values())
2801          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2802          for (Integer v1 : new Integer[] { 1, null })
2803      {
2804          final CompletableFuture<Integer> f = new CompletableFuture<>();
2805          final CompletableFuture<Integer> g = new CompletableFuture<>();
2806 <        final Noop r = new Noop(m);
2807 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2806 >        final Noop[] rs = new Noop[6];
2807 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2808  
2809 <        assertTrue(f.cancel(mayInterruptIfRunning));
2810 <        checkCompletedWithWrappedCancellationException(h);
2811 <        g.complete(v1);
2812 <
2813 <        checkCancelled(f);
2814 <        assertEquals(0, r.invocationCount);
2815 <        checkCompletedNormally(g, v1);
2816 <        checkCompletedWithWrappedCancellationException(h);
2817 <    }}
2818 <
2819 <    public void testRunAfterEither_sourceCancelled2() {
2820 <        for (ExecutionMode m : ExecutionMode.values())
2821 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2822 <        for (Integer v1 : new Integer[] { 1, null })
2823 <    {
2824 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2825 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2826 <        final Noop r = new Noop(m);
2827 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2458 <
2459 <        assertTrue(g.cancel(mayInterruptIfRunning));
2460 <        checkCompletedWithWrappedCancellationException(h);
2461 <        f.complete(v1);
2462 <
2463 <        checkCancelled(g);
2464 <        assertEquals(0, r.invocationCount);
2465 <        checkCompletedNormally(f, v1);
2466 <        checkCompletedWithWrappedCancellationException(h);
2467 <    }}
2468 <
2469 <    public void testRunAfterEither_sourceCancelled3() {
2470 <        for (ExecutionMode m : ExecutionMode.values())
2471 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2472 <        for (Integer v1 : new Integer[] { 1, null })
2473 <    {
2474 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2475 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2476 <        final Noop r = new Noop(m);
2477 <
2478 <        assertTrue(g.cancel(mayInterruptIfRunning));
2479 <        f.complete(v1);
2480 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2481 <
2482 <        // unspecified behavior
2483 <        Integer v;
2809 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2810 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2811 >        checkIncomplete(h0);
2812 >        checkIncomplete(h1);
2813 >        rs[0].assertNotInvoked();
2814 >        rs[1].assertNotInvoked();
2815 >        f.cancel(mayInterruptIfRunning);
2816 >        checkCompletedWithWrappedCancellationException(h0);
2817 >        checkCompletedWithWrappedCancellationException(h1);
2818 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2819 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2820 >        checkCompletedWithWrappedCancellationException(h2);
2821 >        checkCompletedWithWrappedCancellationException(h3);
2822 >
2823 >        assertTrue(g.complete(v1));
2824 >
2825 >        // unspecified behavior - both source completions available
2826 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2827 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2828          try {
2829 <            assertNull(h.join());
2830 <            assertEquals(1, r.invocationCount);
2829 >            assertNull(h4.join());
2830 >            rs[4].assertInvoked();
2831          } catch (CompletionException ok) {
2832 <            checkCompletedWithWrappedCancellationException(h);
2833 <            assertEquals(0, r.invocationCount);
2832 >            checkCompletedWithWrappedCancellationException(h4);
2833 >            rs[4].assertNotInvoked();
2834 >        }
2835 >        try {
2836 >            assertNull(h5.join());
2837 >            rs[5].assertInvoked();
2838 >        } catch (CompletionException ok) {
2839 >            checkCompletedWithWrappedCancellationException(h5);
2840 >            rs[5].assertNotInvoked();
2841          }
2842  
2843 <        checkCancelled(g);
2844 <        checkCompletedNormally(f, v1);
2843 >        checkCancelled(f);
2844 >        checkCompletedNormally(g, v1);
2845 >        checkCompletedWithWrappedCancellationException(h0);
2846 >        checkCompletedWithWrappedCancellationException(h1);
2847 >        checkCompletedWithWrappedCancellationException(h2);
2848 >        checkCompletedWithWrappedCancellationException(h3);
2849 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2850      }}
2851  
2852 <    public void testRunAfterEither_sourceCancelled4() {
2852 >    /**
2853 >     * runAfterEither result completes exceptionally if action does
2854 >     */
2855 >    public void testRunAfterEither_actionFailed() {
2856          for (ExecutionMode m : ExecutionMode.values())
2498 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2857          for (Integer v1 : new Integer[] { 1, null })
2858 +        for (Integer v2 : new Integer[] { 2, null })
2859      {
2860          final CompletableFuture<Integer> f = new CompletableFuture<>();
2861          final CompletableFuture<Integer> g = new CompletableFuture<>();
2862 <        final Noop r = new Noop(m);
2862 >        final FailingRunnable[] rs = new FailingRunnable[6];
2863 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2864  
2865 <        assertTrue(f.cancel(mayInterruptIfRunning));
2866 <        g.complete(v1);
2867 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2868 <
2869 <        // unspecified behavior
2870 <        Integer v;
2871 <        try {
2872 <            assertNull(h.join());
2873 <            assertEquals(1, r.invocationCount);
2874 <        } catch (CompletionException ok) {
2875 <            checkCompletedWithWrappedCancellationException(h);
2876 <            assertEquals(0, r.invocationCount);
2877 <        }
2865 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2866 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2867 >        assertTrue(f.complete(v1));
2868 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2869 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2870 >        checkCompletedWithWrappedCFException(h0);
2871 >        checkCompletedWithWrappedCFException(h1);
2872 >        checkCompletedWithWrappedCFException(h2);
2873 >        checkCompletedWithWrappedCFException(h3);
2874 >        for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2875 >        assertTrue(g.complete(v2));
2876 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2877 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2878 >        checkCompletedWithWrappedCFException(h4);
2879 >        checkCompletedWithWrappedCFException(h5);
2880  
2881 <        checkCancelled(f);
2882 <        checkCompletedNormally(g, v1);
2881 >        checkCompletedNormally(f, v1);
2882 >        checkCompletedNormally(g, v2);
2883 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2884      }}
2885  
2886      /**
# Line 2530 | Line 2893 | public class CompletableFutureTest exten
2893      {
2894          final CompletableFuture<Integer> f = new CompletableFuture<>();
2895          final CompletableFutureInc r = new CompletableFutureInc(m);
2896 <        if (!createIncomplete) f.complete(v1);
2896 >        if (!createIncomplete) assertTrue(f.complete(v1));
2897          final CompletableFuture<Integer> g = m.thenCompose(f, r);
2898 <        if (createIncomplete) f.complete(v1);
2898 >        if (createIncomplete) assertTrue(f.complete(v1));
2899  
2900          checkCompletedNormally(g, inc(v1));
2901          checkCompletedNormally(f, v1);
2902 <        assertEquals(1, r.invocationCount);
2902 >        r.assertValue(v1);
2903      }}
2904  
2905      /**
# Line 2554 | Line 2917 | public class CompletableFutureTest exten
2917          final CompletableFuture<Integer> g = m.thenCompose(f, r);
2918          if (createIncomplete) f.completeExceptionally(ex);
2919  
2920 <        checkCompletedWithWrappedCFException(g, ex);
2921 <        checkCompletedWithWrappedCFException(f, ex);
2922 <        assertEquals(0, r.invocationCount);
2920 >        checkCompletedWithWrappedException(g, ex);
2921 >        checkCompletedExceptionally(f, ex);
2922 >        r.assertNotInvoked();
2923      }}
2924  
2925      /**
# Line 2570 | Line 2933 | public class CompletableFutureTest exten
2933          final CompletableFuture<Integer> f = new CompletableFuture<>();
2934          final FailingCompletableFutureFunction r
2935              = new FailingCompletableFutureFunction(m);
2936 <        if (!createIncomplete) f.complete(v1);
2936 >        if (!createIncomplete) assertTrue(f.complete(v1));
2937          final CompletableFuture<Integer> g = m.thenCompose(f, r);
2938 <        if (createIncomplete) f.complete(v1);
2938 >        if (createIncomplete) assertTrue(f.complete(v1));
2939  
2940          checkCompletedWithWrappedCFException(g);
2941          checkCompletedNormally(f, v1);
# Line 2599 | Line 2962 | public class CompletableFutureTest exten
2962          checkCancelled(f);
2963      }}
2964  
2965 +    /**
2966 +     * thenCompose result completes exceptionally if the result of the action does
2967 +     */
2968 +    public void testThenCompose_actionReturnsFailingFuture() {
2969 +        for (ExecutionMode m : ExecutionMode.values())
2970 +        for (int order = 0; order < 6; order++)
2971 +        for (Integer v1 : new Integer[] { 1, null })
2972 +    {
2973 +        final CFException ex = new CFException();
2974 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
2975 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
2976 +        final CompletableFuture<Integer> h;
2977 +        // Test all permutations of orders
2978 +        switch (order) {
2979 +        case 0:
2980 +            assertTrue(f.complete(v1));
2981 +            assertTrue(g.completeExceptionally(ex));
2982 +            h = m.thenCompose(f, (x -> g));
2983 +            break;
2984 +        case 1:
2985 +            assertTrue(f.complete(v1));
2986 +            h = m.thenCompose(f, (x -> g));
2987 +            assertTrue(g.completeExceptionally(ex));
2988 +            break;
2989 +        case 2:
2990 +            assertTrue(g.completeExceptionally(ex));
2991 +            assertTrue(f.complete(v1));
2992 +            h = m.thenCompose(f, (x -> g));
2993 +            break;
2994 +        case 3:
2995 +            assertTrue(g.completeExceptionally(ex));
2996 +            h = m.thenCompose(f, (x -> g));
2997 +            assertTrue(f.complete(v1));
2998 +            break;
2999 +        case 4:
3000 +            h = m.thenCompose(f, (x -> g));
3001 +            assertTrue(f.complete(v1));
3002 +            assertTrue(g.completeExceptionally(ex));
3003 +            break;
3004 +        case 5:
3005 +            h = m.thenCompose(f, (x -> g));
3006 +            assertTrue(f.complete(v1));
3007 +            assertTrue(g.completeExceptionally(ex));
3008 +            break;
3009 +        default: throw new AssertionError();
3010 +        }
3011 +
3012 +        checkCompletedExceptionally(g, ex);
3013 +        checkCompletedWithWrappedException(h, ex);
3014 +        checkCompletedNormally(f, v1);
3015 +    }}
3016 +
3017      // other static methods
3018  
3019      /**
# Line 2615 | Line 3030 | public class CompletableFutureTest exten
3030       * when all components complete normally
3031       */
3032      public void testAllOf_normal() throws Exception {
3033 <        for (int k = 1; k < 20; ++k) {
3033 >        for (int k = 1; k < 10; k++) {
3034              CompletableFuture<Integer>[] fs
3035                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3036 <            for (int i = 0; i < k; ++i)
3036 >            for (int i = 0; i < k; i++)
3037                  fs[i] = new CompletableFuture<>();
3038              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3039 <            for (int i = 0; i < k; ++i) {
3039 >            for (int i = 0; i < k; i++) {
3040                  checkIncomplete(f);
3041                  checkIncomplete(CompletableFuture.allOf(fs));
3042                  fs[i].complete(one);
# Line 2632 | Line 3047 | public class CompletableFutureTest exten
3047      }
3048  
3049      public void testAllOf_backwards() throws Exception {
3050 <        for (int k = 1; k < 20; ++k) {
3050 >        for (int k = 1; k < 10; k++) {
3051              CompletableFuture<Integer>[] fs
3052                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3053 <            for (int i = 0; i < k; ++i)
3053 >            for (int i = 0; i < k; i++)
3054                  fs[i] = new CompletableFuture<>();
3055              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3056              for (int i = k - 1; i >= 0; i--) {
# Line 2648 | Line 3063 | public class CompletableFutureTest exten
3063          }
3064      }
3065  
3066 +    public void testAllOf_exceptional() throws Exception {
3067 +        for (int k = 1; k < 10; k++) {
3068 +            CompletableFuture<Integer>[] fs
3069 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3070 +            CFException ex = new CFException();
3071 +            for (int i = 0; i < k; i++)
3072 +                fs[i] = new CompletableFuture<>();
3073 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3074 +            for (int i = 0; i < k; i++) {
3075 +                checkIncomplete(f);
3076 +                checkIncomplete(CompletableFuture.allOf(fs));
3077 +                if (i != k / 2) {
3078 +                    fs[i].complete(i);
3079 +                    checkCompletedNormally(fs[i], i);
3080 +                } else {
3081 +                    fs[i].completeExceptionally(ex);
3082 +                    checkCompletedExceptionally(fs[i], ex);
3083 +                }
3084 +            }
3085 +            checkCompletedWithWrappedException(f, ex);
3086 +            checkCompletedWithWrappedException(CompletableFuture.allOf(fs), ex);
3087 +        }
3088 +    }
3089 +
3090      /**
3091       * anyOf(no component futures) returns an incomplete future
3092       */
3093      public void testAnyOf_empty() throws Exception {
3094 +        for (Integer v1 : new Integer[] { 1, null })
3095 +    {
3096          CompletableFuture<Object> f = CompletableFuture.anyOf();
3097          checkIncomplete(f);
3098 <    }
3098 >
3099 >        f.complete(v1);
3100 >        checkCompletedNormally(f, v1);
3101 >    }}
3102  
3103      /**
3104       * anyOf returns a future completed normally with a value when
3105       * a component future does
3106       */
3107      public void testAnyOf_normal() throws Exception {
3108 <        for (int k = 0; k < 10; ++k) {
3108 >        for (int k = 0; k < 10; k++) {
3109              CompletableFuture[] fs = new CompletableFuture[k];
3110 <            for (int i = 0; i < k; ++i)
3110 >            for (int i = 0; i < k; i++)
3111                  fs[i] = new CompletableFuture<>();
3112              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3113              checkIncomplete(f);
3114 <            for (int i = 0; i < k; ++i) {
3115 <                fs[i].complete(one);
3116 <                checkCompletedNormally(f, one);
3117 <                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
3114 >            for (int i = 0; i < k; i++) {
3115 >                fs[i].complete(i);
3116 >                checkCompletedNormally(f, 0);
3117 >                int x = (int) CompletableFuture.anyOf(fs).join();
3118 >                assertTrue(0 <= x && x <= i);
3119 >            }
3120 >        }
3121 >    }
3122 >    public void testAnyOf_normal_backwards() throws Exception {
3123 >        for (int k = 0; k < 10; k++) {
3124 >            CompletableFuture[] fs = new CompletableFuture[k];
3125 >            for (int i = 0; i < k; i++)
3126 >                fs[i] = new CompletableFuture<>();
3127 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3128 >            checkIncomplete(f);
3129 >            for (int i = k - 1; i >= 0; i--) {
3130 >                fs[i].complete(i);
3131 >                checkCompletedNormally(f, k - 1);
3132 >                int x = (int) CompletableFuture.anyOf(fs).join();
3133 >                assertTrue(i <= x && x <= k - 1);
3134              }
3135          }
3136      }
# Line 2679 | Line 3139 | public class CompletableFutureTest exten
3139       * anyOf result completes exceptionally when any component does.
3140       */
3141      public void testAnyOf_exceptional() throws Exception {
3142 <        for (int k = 0; k < 10; ++k) {
3142 >        for (int k = 0; k < 10; k++) {
3143              CompletableFuture[] fs = new CompletableFuture[k];
3144 <            for (int i = 0; i < k; ++i)
3144 >            CFException[] exs = new CFException[k];
3145 >            for (int i = 0; i < k; i++) {
3146                  fs[i] = new CompletableFuture<>();
3147 +                exs[i] = new CFException();
3148 +            }
3149              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3150              checkIncomplete(f);
3151 <            for (int i = 0; i < k; ++i) {
3152 <                fs[i].completeExceptionally(new CFException());
3153 <                checkCompletedWithWrappedCFException(f);
3151 >            for (int i = 0; i < k; i++) {
3152 >                fs[i].completeExceptionally(exs[i]);
3153 >                checkCompletedWithWrappedException(f, exs[0]);
3154 >                checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3155 >            }
3156 >        }
3157 >    }
3158 >
3159 >    public void testAnyOf_exceptional_backwards() throws Exception {
3160 >        for (int k = 0; k < 10; k++) {
3161 >            CompletableFuture[] fs = new CompletableFuture[k];
3162 >            CFException[] exs = new CFException[k];
3163 >            for (int i = 0; i < k; i++) {
3164 >                fs[i] = new CompletableFuture<>();
3165 >                exs[i] = new CFException();
3166 >            }
3167 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3168 >            checkIncomplete(f);
3169 >            for (int i = k - 1; i >= 0; i--) {
3170 >                fs[i].completeExceptionally(exs[i]);
3171 >                checkCompletedWithWrappedException(f, exs[k - 1]);
3172                  checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3173              }
3174          }
# Line 2700 | Line 3181 | public class CompletableFutureTest exten
3181          CompletableFuture<Integer> f = new CompletableFuture<>();
3182          CompletableFuture<Integer> g = new CompletableFuture<>();
3183          CompletableFuture<Integer> nullFuture = (CompletableFuture<Integer>)null;
2703 –        CompletableFuture<?> h;
3184          ThreadExecutor exec = new ThreadExecutor();
3185  
3186          Runnable[] throwingActions = {
3187              () -> CompletableFuture.supplyAsync(null),
3188              () -> CompletableFuture.supplyAsync(null, exec),
3189 <            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
3189 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.SYNC, 42), null),
3190  
3191              () -> CompletableFuture.runAsync(null),
3192              () -> CompletableFuture.runAsync(null, exec),
# Line 2797 | Line 3277 | public class CompletableFutureTest exten
3277              () -> CompletableFuture.anyOf(null, f),
3278  
3279              () -> f.obtrudeException(null),
3280 +
3281 +            () -> CompletableFuture.delayedExecutor(1L, SECONDS, null),
3282 +            () -> CompletableFuture.delayedExecutor(1L, null, new ThreadExecutor()),
3283 +            () -> CompletableFuture.delayedExecutor(1L, null),
3284 +
3285 +            () -> f.orTimeout(1L, null),
3286 +            () -> f.completeOnTimeout(42, 1L, null),
3287 +
3288 +            () -> CompletableFuture.failedFuture(null),
3289 +            () -> CompletableFuture.failedStage(null),
3290          };
3291  
3292          assertThrows(NullPointerException.class, throwingActions);
# Line 2811 | Line 3301 | public class CompletableFutureTest exten
3301          assertSame(f, f.toCompletableFuture());
3302      }
3303  
3304 +    // jdk9
3305 +
3306      /**
3307 <     * whenComplete action executes on normal completion, propagating
2816 <     * source result.
3307 >     * newIncompleteFuture returns an incomplete CompletableFuture
3308       */
3309 <    public void testWhenComplete_normalCompletion1() {
2819 <        for (ExecutionMode m : ExecutionMode.values())
2820 <        for (boolean createIncomplete : new boolean[] { true, false })
3309 >    public void testNewIncompleteFuture() {
3310          for (Integer v1 : new Integer[] { 1, null })
3311      {
3312 <        final AtomicInteger a = new AtomicInteger(0);
3313 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3314 <        if (!createIncomplete) f.complete(v1);
3315 <        final CompletableFuture<Integer> g = m.whenComplete
3316 <            (f,
2828 <             (Integer x, Throwable t) -> {
2829 <                threadAssertSame(x, v1);
2830 <                threadAssertNull(t);
2831 <                a.getAndIncrement();
2832 <            });
2833 <        if (createIncomplete) f.complete(v1);
2834 <
2835 <        checkCompletedNormally(g, v1);
3312 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3313 >        CompletableFuture<Integer> g = f.newIncompleteFuture();
3314 >        checkIncomplete(f);
3315 >        checkIncomplete(g);
3316 >        f.complete(v1);
3317          checkCompletedNormally(f, v1);
3318 <        assertEquals(1, a.get());
3318 >        checkIncomplete(g);
3319 >        g.complete(v1);
3320 >        checkCompletedNormally(g, v1);
3321 >        assertSame(g.getClass(), CompletableFuture.class);
3322      }}
3323  
3324      /**
3325 <     * whenComplete action executes on exceptional completion, propagating
2842 <     * source result.
3325 >     * completedStage returns a completed CompletionStage
3326       */
3327 <    public void testWhenComplete_exceptionalCompletion() {
3328 <        for (ExecutionMode m : ExecutionMode.values())
3329 <        for (boolean createIncomplete : new boolean[] { true, false })
3327 >    public void testCompletedStage() {
3328 >        AtomicInteger x = new AtomicInteger(0);
3329 >        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3330 >        CompletionStage<Integer> f = CompletableFuture.completedStage(1);
3331 >        f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3332 >        assertEquals(x.get(), 1);
3333 >        assertNull(r.get());
3334 >    }
3335 >
3336 >    /**
3337 >     * defaultExecutor by default returns the commonPool if
3338 >     * it supports more than one thread.
3339 >     */
3340 >    public void testDefaultExecutor() {
3341 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3342 >        Executor e = f.defaultExecutor();
3343 >        Executor c = ForkJoinPool.commonPool();
3344 >        if (ForkJoinPool.getCommonPoolParallelism() > 1)
3345 >            assertSame(e, c);
3346 >        else
3347 >            assertNotSame(e, c);
3348 >    }
3349 >
3350 >    /**
3351 >     * failedFuture returns a CompletableFuture completed
3352 >     * exceptionally with the given Exception
3353 >     */
3354 >    public void testFailedFuture() {
3355 >        CFException ex = new CFException();
3356 >        CompletableFuture<Integer> f = CompletableFuture.failedFuture(ex);
3357 >        checkCompletedExceptionally(f, ex);
3358 >    }
3359 >
3360 >    /**
3361 >     * failedFuture(null) throws NPE
3362 >     */
3363 >    public void testFailedFuture_null() {
3364 >        try {
3365 >            CompletableFuture<Integer> f = CompletableFuture.failedFuture(null);
3366 >            shouldThrow();
3367 >        } catch (NullPointerException success) {}
3368 >    }
3369 >
3370 >    /**
3371 >     * copy returns a CompletableFuture that is completed normally,
3372 >     * with the same value, when source is.
3373 >     */
3374 >    public void testCopy() {
3375 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3376 >        CompletableFuture<Integer> g = f.copy();
3377 >        checkIncomplete(f);
3378 >        checkIncomplete(g);
3379 >        f.complete(1);
3380 >        checkCompletedNormally(f, 1);
3381 >        checkCompletedNormally(g, 1);
3382 >    }
3383 >
3384 >    /**
3385 >     * copy returns a CompletableFuture that is completed exceptionally
3386 >     * when source is.
3387 >     */
3388 >    public void testCopy2() {
3389 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3390 >        CompletableFuture<Integer> g = f.copy();
3391 >        checkIncomplete(f);
3392 >        checkIncomplete(g);
3393 >        CFException ex = new CFException();
3394 >        f.completeExceptionally(ex);
3395 >        checkCompletedExceptionally(f, ex);
3396 >        checkCompletedWithWrappedException(g, ex);
3397 >    }
3398 >
3399 >    /**
3400 >     * minimalCompletionStage returns a CompletableFuture that is
3401 >     * completed normally, with the same value, when source is.
3402 >     */
3403 >    public void testMinimalCompletionStage() {
3404 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3405 >        CompletionStage<Integer> g = f.minimalCompletionStage();
3406 >        AtomicInteger x = new AtomicInteger(0);
3407 >        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3408 >        checkIncomplete(f);
3409 >        g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3410 >        f.complete(1);
3411 >        checkCompletedNormally(f, 1);
3412 >        assertEquals(x.get(), 1);
3413 >        assertNull(r.get());
3414 >    }
3415 >
3416 >    /**
3417 >     * minimalCompletionStage returns a CompletableFuture that is
3418 >     * completed exceptionally when source is.
3419 >     */
3420 >    public void testMinimalCompletionStage2() {
3421 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3422 >        CompletionStage<Integer> g = f.minimalCompletionStage();
3423 >        AtomicInteger x = new AtomicInteger(0);
3424 >        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3425 >        g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3426 >        checkIncomplete(f);
3427 >        CFException ex = new CFException();
3428 >        f.completeExceptionally(ex);
3429 >        checkCompletedExceptionally(f, ex);
3430 >        assertEquals(x.get(), 0);
3431 >        assertEquals(r.get().getCause(), ex);
3432 >    }
3433 >
3434 >    /**
3435 >     * failedStage returns a CompletionStage completed
3436 >     * exceptionally with the given Exception
3437 >     */
3438 >    public void testFailedStage() {
3439 >        CFException ex = new CFException();
3440 >        CompletionStage<Integer> f = CompletableFuture.failedStage(ex);
3441 >        AtomicInteger x = new AtomicInteger(0);
3442 >        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3443 >        f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3444 >        assertEquals(x.get(), 0);
3445 >        assertEquals(r.get(), ex);
3446 >    }
3447 >
3448 >    /**
3449 >     * completeAsync completes with value of given supplier
3450 >     */
3451 >    public void testCompleteAsync() {
3452          for (Integer v1 : new Integer[] { 1, null })
3453      {
3454 <        final AtomicInteger a = new AtomicInteger(0);
3455 <        final CFException ex = new CFException();
3456 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3457 <        if (!createIncomplete) f.completeExceptionally(ex);
2853 <        final CompletableFuture<Integer> g = m.whenComplete
2854 <            (f,
2855 <             (Integer x, Throwable t) -> {
2856 <                threadAssertNull(x);
2857 <                threadAssertSame(t, ex);
2858 <                a.getAndIncrement();
2859 <            });
2860 <        if (createIncomplete) f.completeExceptionally(ex);
2861 <        checkCompletedWithWrappedCFException(f, ex);
2862 <        checkCompletedWithWrappedCFException(g, ex);
2863 <        assertEquals(1, a.get());
3454 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3455 >        f.completeAsync(() -> v1);
3456 >        f.join();
3457 >        checkCompletedNormally(f, v1);
3458      }}
3459  
3460      /**
3461 <     * whenComplete action executes on cancelled source, propagating
2868 <     * CancellationException.
3461 >     * completeAsync completes exceptionally if given supplier throws
3462       */
3463 <    public void testWhenComplete_sourceCancelled() {
3464 <        for (ExecutionMode m : ExecutionMode.values())
3465 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3466 <        for (boolean createIncomplete : new boolean[] { true, false })
3463 >    public void testCompleteAsync2() {
3464 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3465 >        CFException ex = new CFException();
3466 >        f.completeAsync(() -> {if (true) throw ex; return 1;});
3467 >        try {
3468 >            f.join();
3469 >            shouldThrow();
3470 >        } catch (CompletionException success) {}
3471 >        checkCompletedWithWrappedException(f, ex);
3472 >    }
3473 >
3474 >    /**
3475 >     * completeAsync with given executor completes with value of given supplier
3476 >     */
3477 >    public void testCompleteAsync3() {
3478 >        for (Integer v1 : new Integer[] { 1, null })
3479      {
3480 <        final AtomicInteger a = new AtomicInteger(0);
3481 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3482 <        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3483 <        final CompletableFuture<Integer> g = m.whenComplete
3484 <            (f,
3485 <             (Integer x, Throwable t) -> {
3486 <                threadAssertNull(x);
2882 <                threadAssertTrue(t instanceof CancellationException);
2883 <                a.getAndIncrement();
2884 <            });
2885 <        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3480 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3481 >        ThreadExecutor executor = new ThreadExecutor();
3482 >        f.completeAsync(() -> v1, executor);
3483 >        assertSame(v1, f.join());
3484 >        checkCompletedNormally(f, v1);
3485 >        assertEquals(1, executor.count.get());
3486 >    }}
3487  
3488 <        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
3489 <        checkCompletedWithWrappedCancellationException(g);
3490 <        checkCancelled(f);
3491 <        assertEquals(1, a.get());
3488 >    /**
3489 >     * completeAsync with given executor completes exceptionally if
3490 >     * given supplier throws
3491 >     */
3492 >    public void testCompleteAsync4() {
3493 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3494 >        CFException ex = new CFException();
3495 >        ThreadExecutor executor = new ThreadExecutor();
3496 >        f.completeAsync(() -> {if (true) throw ex; return 1;}, executor);
3497 >        try {
3498 >            f.join();
3499 >            shouldThrow();
3500 >        } catch (CompletionException success) {}
3501 >        checkCompletedWithWrappedException(f, ex);
3502 >        assertEquals(1, executor.count.get());
3503 >    }
3504 >
3505 >    /**
3506 >     * orTimeout completes with TimeoutException if not complete
3507 >     */
3508 >    public void testOrTimeout_timesOut() {
3509 >        long timeoutMillis = timeoutMillis();
3510 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3511 >        long startTime = System.nanoTime();
3512 >        f.orTimeout(timeoutMillis, MILLISECONDS);
3513 >        checkCompletedWithTimeoutException(f);
3514 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
3515 >    }
3516 >
3517 >    /**
3518 >     * orTimeout completes normally if completed before timeout
3519 >     */
3520 >    public void testOrTimeout_completed() {
3521 >        for (Integer v1 : new Integer[] { 1, null })
3522 >    {
3523 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3524 >        CompletableFuture<Integer> g = new CompletableFuture<>();
3525 >        long startTime = System.nanoTime();
3526 >        f.complete(v1);
3527 >        f.orTimeout(LONG_DELAY_MS, MILLISECONDS);
3528 >        g.orTimeout(LONG_DELAY_MS, MILLISECONDS);
3529 >        g.complete(v1);
3530 >        checkCompletedNormally(f, v1);
3531 >        checkCompletedNormally(g, v1);
3532 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
3533      }}
3534  
3535      /**
3536 <     * If a whenComplete action throws an exception when triggered by
2895 <     * a normal completion, it completes exceptionally
3536 >     * completeOnTimeout completes with given value if not complete
3537       */
3538 <    public void testWhenComplete_actionFailed() {
3539 <        for (boolean createIncomplete : new boolean[] { true, false })
3540 <        for (ExecutionMode m : ExecutionMode.values())
3538 >    public void testCompleteOnTimeout_timesOut() {
3539 >        testInParallel(() -> testCompleteOnTimeout_timesOut(42),
3540 >                       () -> testCompleteOnTimeout_timesOut(null));
3541 >    }
3542 >
3543 >    public void testCompleteOnTimeout_timesOut(Integer v) {
3544 >        long timeoutMillis = timeoutMillis();
3545 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3546 >        long startTime = System.nanoTime();
3547 >        f.completeOnTimeout(v, timeoutMillis, MILLISECONDS);
3548 >        assertSame(v, f.join());
3549 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
3550 >        f.complete(99);         // should have no effect
3551 >        checkCompletedNormally(f, v);
3552 >    }
3553 >
3554 >    /**
3555 >     * completeOnTimeout has no effect if completed within timeout
3556 >     */
3557 >    public void testCompleteOnTimeout_completed() {
3558          for (Integer v1 : new Integer[] { 1, null })
3559      {
3560 <        final AtomicInteger a = new AtomicInteger(0);
3561 <        final CFException ex = new CFException();
3562 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3563 <        if (!createIncomplete) f.complete(v1);
3564 <        final CompletableFuture<Integer> g = m.whenComplete
3565 <            (f,
3566 <             (Integer x, Throwable t) -> {
2909 <                threadAssertSame(x, v1);
2910 <                threadAssertNull(t);
2911 <                a.getAndIncrement();
2912 <                throw ex;
2913 <            });
2914 <        if (createIncomplete) f.complete(v1);
3560 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3561 >        CompletableFuture<Integer> g = new CompletableFuture<>();
3562 >        long startTime = System.nanoTime();
3563 >        f.complete(v1);
3564 >        f.completeOnTimeout(-1, LONG_DELAY_MS, MILLISECONDS);
3565 >        g.completeOnTimeout(-1, LONG_DELAY_MS, MILLISECONDS);
3566 >        g.complete(v1);
3567          checkCompletedNormally(f, v1);
3568 <        checkCompletedWithWrappedCFException(g, ex);
3569 <        assertEquals(1, a.get());
3568 >        checkCompletedNormally(g, v1);
3569 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
3570      }}
3571  
3572      /**
3573 <     * If a whenComplete action throws an exception when triggered by
2922 <     * a source completion that also throws an exception, the source
2923 <     * exception takes precedence.
3573 >     * delayedExecutor returns an executor that delays submission
3574       */
3575 <    public void testWhenComplete_actionFailedSourceFailed() {
3576 <        for (boolean createIncomplete : new boolean[] { true, false })
3575 >    public void testDelayedExecutor() {
3576 >        testInParallel(() -> testDelayedExecutor(null, null),
3577 >                       () -> testDelayedExecutor(null, 1),
3578 >                       () -> testDelayedExecutor(new ThreadExecutor(), 1),
3579 >                       () -> testDelayedExecutor(new ThreadExecutor(), 1));
3580 >    }
3581 >
3582 >    public void testDelayedExecutor(Executor executor, Integer v) throws Exception {
3583 >        long timeoutMillis = timeoutMillis();
3584 >        // Use an "unreasonably long" long timeout to catch lingering threads
3585 >        long longTimeoutMillis = 1000 * 60 * 60 * 24;
3586 >        final Executor delayer, longDelayer;
3587 >        if (executor == null) {
3588 >            delayer = CompletableFuture.delayedExecutor(timeoutMillis, MILLISECONDS);
3589 >            longDelayer = CompletableFuture.delayedExecutor(longTimeoutMillis, MILLISECONDS);
3590 >        } else {
3591 >            delayer = CompletableFuture.delayedExecutor(timeoutMillis, MILLISECONDS, executor);
3592 >            longDelayer = CompletableFuture.delayedExecutor(longTimeoutMillis, MILLISECONDS, executor);
3593 >        }
3594 >        long startTime = System.nanoTime();
3595 >        CompletableFuture<Integer> f =
3596 >            CompletableFuture.supplyAsync(() -> v, delayer);
3597 >        CompletableFuture<Integer> g =
3598 >            CompletableFuture.supplyAsync(() -> v, longDelayer);
3599 >
3600 >        assertNull(g.getNow(null));
3601 >
3602 >        assertSame(v, f.get(LONG_DELAY_MS, MILLISECONDS));
3603 >        long millisElapsed = millisElapsedSince(startTime);
3604 >        assertTrue(millisElapsed >= timeoutMillis);
3605 >        assertTrue(millisElapsed < LONG_DELAY_MS / 2);
3606 >
3607 >        checkCompletedNormally(f, v);
3608 >
3609 >        checkIncomplete(g);
3610 >        assertTrue(g.cancel(true));
3611 >    }
3612 >
3613 >    //--- tests of implementation details; not part of official tck ---
3614 >
3615 >    Object resultOf(CompletableFuture<?> f) {
3616 >        try {
3617 >            java.lang.reflect.Field resultField
3618 >                = CompletableFuture.class.getDeclaredField("result");
3619 >            resultField.setAccessible(true);
3620 >            return resultField.get(f);
3621 >        } catch (Throwable t) { throw new AssertionError(t); }
3622 >    }
3623 >
3624 >    public void testExceptionPropagationReusesResultObject() {
3625 >        if (!testImplementationDetails) return;
3626          for (ExecutionMode m : ExecutionMode.values())
2928 –        for (Integer v1 : new Integer[] { 1, null })
3627      {
3628 <        final AtomicInteger a = new AtomicInteger(0);
3629 <        final CFException ex1 = new CFException();
3630 <        final CFException ex2 = new CFException();
2933 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3628 >        final CFException ex = new CFException();
3629 >        final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3630 >        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3631  
3632 <        if (!createIncomplete) f.completeExceptionally(ex1);
3633 <        final CompletableFuture<Integer> g = m.whenComplete
2937 <            (f,
2938 <             (Integer x, Throwable t) -> {
2939 <                threadAssertSame(t, ex1);
2940 <                threadAssertNull(x);
2941 <                a.getAndIncrement();
2942 <                throw ex2;
2943 <            });
2944 <        if (createIncomplete) f.completeExceptionally(ex1);
3632 >        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3633 >            = new ArrayList<>();
3634  
3635 <        checkCompletedWithWrappedCFException(f, ex1);
3636 <        checkCompletedWithWrappedCFException(g, ex1);
3637 <        assertEquals(1, a.get());
3635 >        funs.add((y) -> m.thenRun(y, new Noop(m)));
3636 >        funs.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3637 >        funs.add((y) -> m.thenApply(y, new IncFunction(m)));
3638 >
3639 >        funs.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3640 >        funs.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3641 >        funs.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3642 >
3643 >        funs.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3644 >        funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3645 >        funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3646 >
3647 >        funs.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3648 >
3649 >        funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3650 >
3651 >        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
3652 >        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
3653 >
3654 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3655 >                 fun : funs) {
3656 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3657 >            f.completeExceptionally(ex);
3658 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3659 >            checkCompletedWithWrappedException(src, ex);
3660 >            CompletableFuture<?> dep = fun.apply(src);
3661 >            checkCompletedWithWrappedException(dep, ex);
3662 >            assertSame(resultOf(src), resultOf(dep));
3663 >        }
3664 >
3665 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3666 >                 fun : funs) {
3667 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3668 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3669 >            CompletableFuture<?> dep = fun.apply(src);
3670 >            f.completeExceptionally(ex);
3671 >            checkCompletedWithWrappedException(src, ex);
3672 >            checkCompletedWithWrappedException(dep, ex);
3673 >            assertSame(resultOf(src), resultOf(dep));
3674 >        }
3675 >
3676 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3677 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3678 >                 fun : funs) {
3679 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3680 >            f.cancel(mayInterruptIfRunning);
3681 >            checkCancelled(f);
3682 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3683 >            checkCompletedWithWrappedCancellationException(src);
3684 >            CompletableFuture<?> dep = fun.apply(src);
3685 >            checkCompletedWithWrappedCancellationException(dep);
3686 >            assertSame(resultOf(src), resultOf(dep));
3687 >        }
3688 >
3689 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3690 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3691 >                 fun : funs) {
3692 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3693 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3694 >            CompletableFuture<?> dep = fun.apply(src);
3695 >            f.cancel(mayInterruptIfRunning);
3696 >            checkCancelled(f);
3697 >            checkCompletedWithWrappedCancellationException(src);
3698 >            checkCompletedWithWrappedCancellationException(dep);
3699 >            assertSame(resultOf(src), resultOf(dep));
3700 >        }
3701      }}
3702  
3703 +    /**
3704 +     * Minimal completion stages throw UOE for all non-CompletionStage methods
3705 +     */
3706 +    public void testMinimalCompletionStage_minimality() {
3707 +        if (!testImplementationDetails) return;
3708 +        Function<Method, String> toSignature =
3709 +            (method) -> method.getName() + Arrays.toString(method.getParameterTypes());
3710 +        Predicate<Method> isNotStatic =
3711 +            (method) -> (method.getModifiers() & Modifier.STATIC) == 0;
3712 +        List<Method> minimalMethods =
3713 +            Stream.of(Object.class, CompletionStage.class)
3714 +            .flatMap((klazz) -> Stream.of(klazz.getMethods()))
3715 +            .filter(isNotStatic)
3716 +            .collect(Collectors.toList());
3717 +        // Methods from CompletableFuture permitted NOT to throw UOE
3718 +        String[] signatureWhitelist = {
3719 +            "newIncompleteFuture[]",
3720 +            "defaultExecutor[]",
3721 +            "minimalCompletionStage[]",
3722 +            "copy[]",
3723 +        };
3724 +        Set<String> permittedMethodSignatures =
3725 +            Stream.concat(minimalMethods.stream().map(toSignature),
3726 +                          Stream.of(signatureWhitelist))
3727 +            .collect(Collectors.toSet());
3728 +        List<Method> allMethods = Stream.of(CompletableFuture.class.getMethods())
3729 +            .filter(isNotStatic)
3730 +            .filter((method) -> !permittedMethodSignatures.contains(toSignature.apply(method)))
3731 +            .collect(Collectors.toList());
3732 +
3733 +        CompletionStage<Integer> minimalStage =
3734 +            new CompletableFuture<Integer>().minimalCompletionStage();
3735 +
3736 +        List<Method> bugs = new ArrayList<>();
3737 +        for (Method method : allMethods) {
3738 +            Class<?>[] parameterTypes = method.getParameterTypes();
3739 +            Object[] args = new Object[parameterTypes.length];
3740 +            // Manufacture boxed primitives for primitive params
3741 +            for (int i = 0; i < args.length; i++) {
3742 +                Class<?> type = parameterTypes[i];
3743 +                if (parameterTypes[i] == boolean.class)
3744 +                    args[i] = false;
3745 +                else if (parameterTypes[i] == int.class)
3746 +                    args[i] = 0;
3747 +                else if (parameterTypes[i] == long.class)
3748 +                    args[i] = 0L;
3749 +            }
3750 +            try {
3751 +                method.invoke(minimalStage, args);
3752 +                bugs.add(method);
3753 +            }
3754 +            catch (java.lang.reflect.InvocationTargetException expected) {
3755 +                if (! (expected.getCause() instanceof UnsupportedOperationException)) {
3756 +                    bugs.add(method);
3757 +                    // expected.getCause().printStackTrace();
3758 +                }
3759 +            }
3760 +            catch (ReflectiveOperationException bad) { throw new Error(bad); }
3761 +        }
3762 +        if (!bugs.isEmpty())
3763 +            throw new Error("Methods did not throw UOE: " + bugs.toString());
3764 +    }
3765 +
3766 +    static class Monad {
3767 +        static class MonadError extends Error {
3768 +            public MonadError() { super("monadic zero"); }
3769 +        }
3770 +        // "return", "unit"
3771 +        static <T> CompletableFuture<T> unit(T value) {
3772 +            return completedFuture(value);
3773 +        }
3774 +        // monadic zero ?
3775 +        static <T> CompletableFuture<T> zero() {
3776 +            return failedFuture(new MonadError());
3777 +        }
3778 +        // >=>
3779 +        static <T,U,V> Function<T, CompletableFuture<V>> compose
3780 +            (Function<T, CompletableFuture<U>> f,
3781 +             Function<U, CompletableFuture<V>> g) {
3782 +            return (x) -> f.apply(x).thenCompose(g);
3783 +        }
3784 +
3785 +        static void assertZero(CompletableFuture<?> f) {
3786 +            try {
3787 +                f.getNow(null);
3788 +                throw new AssertionFailedError("should throw");
3789 +            } catch (CompletionException success) {
3790 +                assertTrue(success.getCause() instanceof MonadError);
3791 +            }
3792 +        }
3793 +
3794 +        static <T> void assertFutureEquals(CompletableFuture<T> f,
3795 +                                           CompletableFuture<T> g) {
3796 +            T fval = null, gval = null;
3797 +            Throwable fex = null, gex = null;
3798 +
3799 +            try { fval = f.get(); }
3800 +            catch (ExecutionException ex) { fex = ex.getCause(); }
3801 +            catch (Throwable ex) { fex = ex; }
3802 +
3803 +            try { gval = g.get(); }
3804 +            catch (ExecutionException ex) { gex = ex.getCause(); }
3805 +            catch (Throwable ex) { gex = ex; }
3806 +
3807 +            if (fex != null || gex != null)
3808 +                assertSame(fex.getClass(), gex.getClass());
3809 +            else
3810 +                assertEquals(fval, gval);
3811 +        }
3812 +
3813 +        static class PlusFuture<T> extends CompletableFuture<T> {
3814 +            AtomicReference<Throwable> firstFailure = new AtomicReference<>(null);
3815 +        }
3816 +
3817 +        // Monadic "plus"
3818 +        static <T> CompletableFuture<T> plus(CompletableFuture<? extends T> f,
3819 +                                             CompletableFuture<? extends T> g) {
3820 +            PlusFuture<T> plus = new PlusFuture<T>();
3821 +            BiConsumer<T, Throwable> action = (T result, Throwable ex) -> {
3822 +                if (ex == null) {
3823 +                    if (plus.complete(result))
3824 +                        if (plus.firstFailure.get() != null)
3825 +                            plus.firstFailure.set(null);
3826 +                }
3827 +                else if (plus.firstFailure.compareAndSet(null, ex)) {
3828 +                    if (plus.isDone())
3829 +                        plus.firstFailure.set(null);
3830 +                } else {
3831 +                    // prefer failing with first failure
3832 +                    plus.completeExceptionally(plus.firstFailure.getAndSet(null));
3833 +                }
3834 +            };
3835 +            f.whenComplete(action);
3836 +            g.whenComplete(action);
3837 +            return plus;
3838 +        }
3839 +    }
3840 +
3841 +    /**
3842 +     * CompletableFuture is an additive monad - sort of.
3843 +     * https://en.wikipedia.org/wiki/Monad_(functional_programming)#Additive_monads
3844 +     */
3845 +    public void testAdditiveMonad() throws Throwable {
3846 +        Function<Long, CompletableFuture<Long>> unit = Monad::unit;
3847 +        CompletableFuture<Long> zero = Monad.zero();
3848 +
3849 +        // Some mutually non-commutative functions
3850 +        Function<Long, CompletableFuture<Long>> triple
3851 +            = (x) -> Monad.unit(3 * x);
3852 +        Function<Long, CompletableFuture<Long>> inc
3853 +            = (x) -> Monad.unit(x + 1);
3854 +
3855 +        // unit is a right identity: m >>= unit === m
3856 +        Monad.assertFutureEquals(inc.apply(5L).thenCompose(unit),
3857 +                                 inc.apply(5L));
3858 +        // unit is a left identity: (unit x) >>= f === f x
3859 +        Monad.assertFutureEquals(unit.apply(5L).thenCompose(inc),
3860 +                                 inc.apply(5L));
3861 +
3862 +        // associativity: (m >>= f) >>= g === m >>= ( \x -> (f x >>= g) )
3863 +        Monad.assertFutureEquals(
3864 +            unit.apply(5L).thenCompose(inc).thenCompose(triple),
3865 +            unit.apply(5L).thenCompose((x) -> inc.apply(x).thenCompose(triple)));
3866 +
3867 +        // The case for CompletableFuture as an additive monad is weaker...
3868 +
3869 +        // zero is a monadic zero
3870 +        Monad.assertZero(zero);
3871 +
3872 +        // left zero: zero >>= f === zero
3873 +        Monad.assertZero(zero.thenCompose(inc));
3874 +        // right zero: f >>= (\x -> zero) === zero
3875 +        Monad.assertZero(inc.apply(5L).thenCompose((x) -> zero));
3876 +
3877 +        // f plus zero === f
3878 +        Monad.assertFutureEquals(Monad.unit(5L),
3879 +                                 Monad.plus(Monad.unit(5L), zero));
3880 +        // zero plus f === f
3881 +        Monad.assertFutureEquals(Monad.unit(5L),
3882 +                                 Monad.plus(zero, Monad.unit(5L)));
3883 +        // zero plus zero === zero
3884 +        Monad.assertZero(Monad.plus(zero, zero));
3885 +        {
3886 +            CompletableFuture<Long> f = Monad.plus(Monad.unit(5L),
3887 +                                                   Monad.unit(8L));
3888 +            // non-determinism
3889 +            assertTrue(f.get() == 5L || f.get() == 8L);
3890 +        }
3891 +
3892 +        CompletableFuture<Long> godot = new CompletableFuture<>();
3893 +        // f plus godot === f (doesn't wait for godot)
3894 +        Monad.assertFutureEquals(Monad.unit(5L),
3895 +                                 Monad.plus(Monad.unit(5L), godot));
3896 +        // godot plus f === f (doesn't wait for godot)
3897 +        Monad.assertFutureEquals(Monad.unit(5L),
3898 +                                 Monad.plus(godot, Monad.unit(5L)));
3899 +    }
3900 +
3901 + //     static <U> U join(CompletionStage<U> stage) {
3902 + //         CompletableFuture<U> f = new CompletableFuture<>();
3903 + //         stage.whenComplete((v, ex) -> {
3904 + //             if (ex != null) f.completeExceptionally(ex); else f.complete(v);
3905 + //         });
3906 + //         return f.join();
3907 + //     }
3908 +
3909 + //     static <U> boolean isDone(CompletionStage<U> stage) {
3910 + //         CompletableFuture<U> f = new CompletableFuture<>();
3911 + //         stage.whenComplete((v, ex) -> {
3912 + //             if (ex != null) f.completeExceptionally(ex); else f.complete(v);
3913 + //         });
3914 + //         return f.isDone();
3915 + //     }
3916 +
3917 + //     static <U> U join2(CompletionStage<U> stage) {
3918 + //         return stage.toCompletableFuture().copy().join();
3919 + //     }
3920 +
3921 + //     static <U> boolean isDone2(CompletionStage<U> stage) {
3922 + //         return stage.toCompletableFuture().copy().isDone();
3923 + //     }
3924 +
3925   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines