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.60 by jsr166, Tue Jun 3 06:16:41 2014 UTC vs.
Revision 1.123 by jsr166, Tue Sep 8 19:45:35 2015 UTC

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

Diff Legend

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