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.193 by jsr166, Tue Jan 30 04:07:09 2018 UTC

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

Diff Legend

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