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.64 by jsr166, Fri Jun 6 17:08:48 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 477 | Line 514 | public class CompletableFutureTest exten
514          }
515      }
516  
480 –
517      class CompletableFutureInc extends CheckedIntegerAction
518          implements Function<Integer, CompletableFuture<Integer>>
519      {
# Line 486 | Line 522 | public class CompletableFutureTest exten
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      }
# Line 516 | 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 597 | 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 794 | 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  
811 –
850      /**
851       * exceptionally action completes with function value on source
852       * exception
# Line 823 | 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 836 | Line 874 | public class CompletableFutureTest exten
874  
875      public void testExceptionally_exceptionalCompletionActionFailed() {
876          for (boolean createIncomplete : new boolean[] { true, false })
839 –        for (Integer v1 : new Integer[] { 1, null })
877      {
878          final AtomicInteger a = new AtomicInteger(0);
879          final CFException ex1 = new CFException();
# Line 845 | 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 <        checkCompletedWithWrappedCFException(g, ex2);
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 >        checkCompletedWithWrappedException(g, ex1);
1033 >        checkCompletedExceptionally(f, ex1);
1034          assertEquals(1, a.get());
1035      }}
1036  
# Line 867 | 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 877 | 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 909 | 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 965 | 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 978 | 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 988 | 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 1069 | Line 1247 | public class CompletableFutureTest exten
1247       */
1248      public void testThenRun_normalCompletion() {
1249          for (ExecutionMode m : ExecutionMode.values())
1072 –        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);
1078 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1079 <        if (createIncomplete) {
1080 <            checkIncomplete(g);
1081 <            f.complete(v1);
1082 <        }
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 <        r.assertInvoked();
1274 >        for (Noop r : rs) r.assertInvoked();
1275      }}
1276  
1277      /**
# Line 1092 | Line 1280 | public class CompletableFutureTest exten
1280       */
1281      public void testThenRun_exceptionalCompletion() {
1282          for (ExecutionMode m : ExecutionMode.values())
1095 –        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);
1101 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1102 <        if (createIncomplete) {
1103 <            checkIncomplete(g);
1104 <            f.completeExceptionally(ex);
1105 <        }
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 <        r.assertNotInvoked();
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 1114 | Line 1312 | public class CompletableFutureTest exten
1312       */
1313      public void testThenRun_sourceCancelled() {
1314          for (ExecutionMode m : ExecutionMode.values())
1117 –        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));
1123 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1124 <        if (createIncomplete) {
1125 <            checkIncomplete(g);
1126 <            assertTrue(f.cancel(mayInterruptIfRunning));
1127 <        }
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 <        r.assertNotInvoked();
1339 >        for (Noop r : rs) r.assertNotInvoked();
1340      }}
1341  
1342      /**
# Line 1136 | Line 1344 | public class CompletableFutureTest exten
1344       */
1345      public void testThenRun_actionFailed() {
1346          for (ExecutionMode m : ExecutionMode.values())
1139 –        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);
1145 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1146 <        if (createIncomplete) {
1147 <            checkIncomplete(g);
1148 <            f.complete(v1);
1149 <        }
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 1157 | Line 1372 | public class CompletableFutureTest exten
1372       */
1373      public void testThenApply_normalCompletion() {
1374          for (ExecutionMode m : ExecutionMode.values())
1160 –        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);
1166 <        final CompletableFuture<Integer> g = m.thenApply(f, r);
1167 <        if (createIncomplete) {
1168 <            checkIncomplete(g);
1169 <            f.complete(v1);
1170 <        }
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 <        r.assertInvoked();
1394 >        for (IncFunction r : rs) r.assertValue(inc(v1));
1395      }}
1396  
1397      /**
# Line 1180 | Line 1400 | public class CompletableFutureTest exten
1400       */
1401      public void testThenApply_exceptionalCompletion() {
1402          for (ExecutionMode m : ExecutionMode.values())
1183 –        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);
1189 <        final CompletableFuture<Integer> g = m.thenApply(f, r);
1190 <        if (createIncomplete) {
1191 <            checkIncomplete(g);
1192 <            f.completeExceptionally(ex);
1193 <        }
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 <        r.assertNotInvoked();
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 1202 | Line 1425 | public class CompletableFutureTest exten
1425       */
1426      public void testThenApply_sourceCancelled() {
1427          for (ExecutionMode m : ExecutionMode.values())
1205 –        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));
1211 <        final CompletableFuture<Integer> g = m.thenApply(f, r);
1212 <        if (createIncomplete) {
1213 <            checkIncomplete(g);
1214 <            assertTrue(f.cancel(mayInterruptIfRunning));
1215 <        }
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 <        r.assertNotInvoked();
1445 >        for (IncFunction r : rs) r.assertNotInvoked();
1446      }}
1447  
1448      /**
# Line 1224 | Line 1450 | public class CompletableFutureTest exten
1450       */
1451      public void testThenApply_actionFailed() {
1452          for (ExecutionMode m : ExecutionMode.values())
1227 –        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);
1233 <        final CompletableFuture<Integer> g = m.thenApply(f, r);
1234 <        if (createIncomplete) {
1235 <            checkIncomplete(g);
1236 <            f.complete(v1);
1237 <        }
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 1245 | Line 1474 | public class CompletableFutureTest exten
1474       */
1475      public void testThenAccept_normalCompletion() {
1476          for (ExecutionMode m : ExecutionMode.values())
1248 –        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 NoopConsumer r = new NoopConsumer(m);
1481 <        if (!createIncomplete) f.complete(v1);
1254 <        final CompletableFuture<Void> g = m.thenAccept(f, r);
1255 <        if (createIncomplete) {
1256 <            checkIncomplete(g);
1257 <            f.complete(v1);
1258 <        }
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);
1484 <        r.assertValue(v1);
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 +        for (NoopConsumer r : rs) r.assertValue(v1);
1497      }}
1498  
1499      /**
# Line 1268 | Line 1502 | public class CompletableFutureTest exten
1502       */
1503      public void testThenAccept_exceptionalCompletion() {
1504          for (ExecutionMode m : ExecutionMode.values())
1271 –        for (boolean createIncomplete : new boolean[] { true, false })
1505      {
1506          final CFException ex = new CFException();
1507          final CompletableFuture<Integer> f = new CompletableFuture<>();
1508 <        final NoopConsumer r = new NoopConsumer(m);
1509 <        if (!createIncomplete) f.completeExceptionally(ex);
1277 <        final CompletableFuture<Void> g = m.thenAccept(f, r);
1278 <        if (createIncomplete) {
1279 <            checkIncomplete(g);
1280 <            f.completeExceptionally(ex);
1281 <        }
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 <        r.assertNotInvoked();
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      /**
# Line 1290 | Line 1527 | public class CompletableFutureTest exten
1527       */
1528      public void testThenAccept_sourceCancelled() {
1529          for (ExecutionMode m : ExecutionMode.values())
1293 –        for (boolean createIncomplete : new boolean[] { true, false })
1530          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1531      {
1532          final CompletableFuture<Integer> f = new CompletableFuture<>();
1533 <        final NoopConsumer r = new NoopConsumer(m);
1534 <        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1299 <        final CompletableFuture<Void> g = m.thenAccept(f, r);
1300 <        if (createIncomplete) {
1301 <            checkIncomplete(g);
1302 <            assertTrue(f.cancel(mayInterruptIfRunning));
1303 <        }
1533 >        final NoopConsumer[] rs = new NoopConsumer[4];
1534 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1535  
1536 <        checkCompletedWithWrappedCancellationException(g);
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 <        r.assertNotInvoked();
1547 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1548      }}
1549  
1550      /**
# Line 1312 | Line 1552 | public class CompletableFutureTest exten
1552       */
1553      public void testThenAccept_actionFailed() {
1554          for (ExecutionMode m : ExecutionMode.values())
1315 –        for (boolean createIncomplete : new boolean[] { true, false })
1555          for (Integer v1 : new Integer[] { 1, null })
1556      {
1557          final CompletableFuture<Integer> f = new CompletableFuture<>();
1558 <        final FailingConsumer r = new FailingConsumer(m);
1559 <        if (!createIncomplete) f.complete(v1);
1321 <        final CompletableFuture<Void> g = m.thenAccept(f, r);
1322 <        if (createIncomplete) {
1323 <            checkIncomplete(g);
1324 <            f.complete(v1);
1325 <        }
1558 >        final FailingConsumer[] rs = new FailingConsumer[4];
1559 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
1560  
1561 <        checkCompletedWithWrappedCFException(g);
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  
# Line 1334 | Line 1577 | public class CompletableFutureTest exten
1577       */
1578      public void testThenCombine_normalCompletion() {
1579          for (ExecutionMode m : ExecutionMode.values())
1337 –        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 <            r.assertNotInvoked();
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  
1356 –        checkCompletedNormally(h, subtract(v1, v2));
1615          checkCompletedNormally(f, v1);
1616          checkCompletedNormally(g, v2);
1359 –        r.assertInvoked();
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())
1368 –        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 <        r.assertNotInvoked();
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 either source cancelled
1665       */
1666 <    public void testThenCombine_sourceCancelled() {
1666 >    public void testThenCombine_sourceCancelled() throws Throwable {
1667          for (ExecutionMode m : ExecutionMode.values())
1668          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1398 –        for (boolean createIncomplete : 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 })
1672      {
1673          final CompletableFuture<Integer> f = new CompletableFuture<>();
1674          final CompletableFuture<Integer> g = new CompletableFuture<>();
1675 <        final SubtractFunction r = new SubtractFunction(m);
1675 >        final SubtractFunction r1 = new SubtractFunction(m);
1676 >        final SubtractFunction r2 = new SubtractFunction(m);
1677 >        final SubtractFunction r3 = new SubtractFunction(m);
1678  
1679 <        (fFirst ? f : g).complete(v1);
1680 <        if (!createIncomplete)
1681 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1682 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1683 <        if (createIncomplete) {
1684 <            checkIncomplete(h);
1685 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1686 <        }
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 <        checkCompletedWithWrappedCancellationException(h);
1689 <        checkCancelled(!fFirst ? f : g);
1690 <        r.assertNotInvoked();
1691 <        checkCompletedNormally(fFirst ? f : g, v1);
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      /**
# Line 1429 | Line 1714 | public class CompletableFutureTest exten
1714      {
1715          final CompletableFuture<Integer> f = new CompletableFuture<>();
1716          final CompletableFuture<Integer> g = new CompletableFuture<>();
1717 <        final FailingBiFunction r = new FailingBiFunction(m);
1718 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
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 <        if (fFirst) {
1733 <            f.complete(v1);
1734 <            g.complete(v2);
1735 <        } else {
1736 <            g.complete(v2);
1737 <            f.complete(v1);
1441 <        }
1442 <
1443 <        checkCompletedWithWrappedCFException(h);
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      }}
# Line 1451 | Line 1745 | public class CompletableFutureTest exten
1745       */
1746      public void testThenAcceptBoth_normalCompletion() {
1747          for (ExecutionMode m : ExecutionMode.values())
1454 –        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 <            r.assertNotInvoked();
1763 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1764 <        }
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(h, null);
1774 <        r.assertValue(subtract(v1, v2));
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 1480 | 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())
1485 –        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 <        r.assertNotInvoked();
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 either source cancelled
1829       */
1830 <    public void testThenAcceptBoth_sourceCancelled() {
1830 >    public void testThenAcceptBoth_sourceCancelled() throws Throwable {
1831          for (ExecutionMode m : ExecutionMode.values())
1832          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1515 –        for (boolean createIncomplete : 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 })
1836      {
1837          final CompletableFuture<Integer> f = new CompletableFuture<>();
1838          final CompletableFuture<Integer> g = new CompletableFuture<>();
1839 <        final SubtractAction r = new SubtractAction(m);
1839 >        final SubtractAction r1 = new SubtractAction(m);
1840 >        final SubtractAction r2 = new SubtractAction(m);
1841 >        final SubtractAction r3 = new SubtractAction(m);
1842  
1843 <        (fFirst ? f : g).complete(v1);
1844 <        if (!createIncomplete)
1845 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1846 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1847 <        if (createIncomplete) {
1848 <            checkIncomplete(h);
1849 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1850 <        }
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 <        checkCompletedWithWrappedCancellationException(h);
1853 <        checkCancelled(!fFirst ? f : g);
1854 <        r.assertNotInvoked();
1855 <        checkCompletedNormally(fFirst ? f : g, v1);
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      /**
# Line 1546 | Line 1878 | public class CompletableFutureTest exten
1878      {
1879          final CompletableFuture<Integer> f = new CompletableFuture<>();
1880          final CompletableFuture<Integer> g = new CompletableFuture<>();
1881 <        final FailingBiConsumer r = new FailingBiConsumer(m);
1882 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1883 <
1884 <        if (fFirst) {
1885 <            f.complete(v1);
1886 <            g.complete(v2);
1887 <        } else {
1888 <            g.complete(v2);
1889 <            f.complete(v1);
1890 <        }
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 <        checkCompletedWithWrappedCFException(h);
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      }}
# Line 1568 | Line 1909 | public class CompletableFutureTest exten
1909       */
1910      public void testRunAfterBoth_normalCompletion() {
1911          for (ExecutionMode m : ExecutionMode.values())
1571 –        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 <            r.assertNotInvoked();
1927 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1928 <        }
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(h, null);
1938 <        r.assertInvoked();
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 1597 | 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())
1602 –        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 <        r.assertNotInvoked();
1973 <        checkCompletedNormally(fFirst ? f : g, v1);
1974 <        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
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 })
1632 –        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);
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 <        (fFirst ? f : g).complete(v1);
2017 <        if (!createIncomplete)
2018 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
2019 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2020 <        if (createIncomplete) {
2021 <            checkIncomplete(h);
2022 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1648 <        }
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(h);
2025 <        checkCancelled(!fFirst ? f : g);
2026 <        r.assertNotInvoked();
2027 <        checkCompletedNormally(fFirst ? f : g, v1);
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      /**
# Line 1666 | Line 2044 | public class CompletableFutureTest exten
2044          final CompletableFuture<Integer> g = new CompletableFuture<>();
2045          final FailingRunnable r1 = new FailingRunnable(m);
2046          final FailingRunnable r2 = new FailingRunnable(m);
2047 +        final FailingRunnable r3 = new FailingRunnable(m);
2048  
2049 <        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2050 <        if (fFirst) {
2051 <            f.complete(v1);
2052 <            g.complete(v2);
2053 <        } else {
2054 <            g.complete(v2);
2055 <            f.complete(v1);
2056 <        }
2057 <        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
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);
2068      }}
# Line 1752 | Line 2136 | public class CompletableFutureTest exten
2136          rs[0].assertNotInvoked();
2137          rs[1].assertNotInvoked();
2138          f.completeExceptionally(ex);
2139 <        checkCompletedWithWrappedCFException(h0, ex);
2140 <        checkCompletedWithWrappedCFException(h1, 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 <        checkCompletedWithWrappedCFException(h2, ex);
2144 <        checkCompletedWithWrappedCFException(h3, ex);
2143 >        checkCompletedWithWrappedException(h2, ex);
2144 >        checkCompletedWithWrappedException(h3, ex);
2145          g.complete(v1);
2146  
2147          // unspecified behavior - both source completions available
# Line 1765 | Line 2149 | public class CompletableFutureTest exten
2149          final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2150          try {
2151              assertEquals(inc(v1), h4.join());
2152 <            rs[4].assertInvoked();
2152 >            rs[4].assertValue(inc(v1));
2153          } catch (CompletionException ok) {
2154 <            checkCompletedWithWrappedCFException(h4, ex);
2154 >            checkCompletedWithWrappedException(h4, ex);
2155              rs[4].assertNotInvoked();
2156          }
2157          try {
2158              assertEquals(inc(v1), h5.join());
2159 <            rs[5].assertInvoked();
2159 >            rs[5].assertValue(inc(v1));
2160          } catch (CompletionException ok) {
2161 <            checkCompletedWithWrappedCFException(h5, ex);
2161 >            checkCompletedWithWrappedException(h5, ex);
2162              rs[5].assertNotInvoked();
2163          }
2164  
2165 <        checkCompletedWithWrappedCFException(f, ex);
2165 >        checkCompletedExceptionally(f, ex);
2166          checkCompletedNormally(g, v1);
2167 <        checkCompletedWithWrappedCFException(h0, ex);
2168 <        checkCompletedWithWrappedCFException(h1, ex);
2169 <        checkCompletedWithWrappedCFException(h2, ex);
2170 <        checkCompletedWithWrappedCFException(h3, ex);
2171 <        checkCompletedWithWrappedCFException(h4, ex);
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())
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<>();
2182 +        final CFException ex = new CFException();
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 - 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 +            rs[1].assertValue(inc(v1));
2204 +        } catch (CompletionException ok) {
2205 +            checkCompletedWithWrappedException(h1, ex);
2206 +            rs[1].assertNotInvoked();
2207 +        }
2208 +        try {
2209 +            assertEquals(inc(v1), h2.join());
2210 +            rs[2].assertValue(inc(v1));
2211 +        } catch (CompletionException ok) {
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 +
2223 +        checkCompletedNormally(f, v1);
2224 +        checkCompletedExceptionally(g, ex);
2225 +    }}
2226 +
2227      /**
2228       * applyToEither result completes exceptionally if either source cancelled
2229       */
# Line 1821 | Line 2257 | public class CompletableFutureTest exten
2257          final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
2258          try {
2259              assertEquals(inc(v1), h4.join());
2260 <            rs[4].assertInvoked();
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].assertInvoked();
2267 >            rs[5].assertValue(inc(v1));
2268          } catch (CompletionException ok) {
2269              checkCompletedWithWrappedCancellationException(h5);
2270              rs[5].assertNotInvoked();
# Line 1843 | Line 2279 | public class CompletableFutureTest exten
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 })
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[] rs = new IncFunction[6];
2291 +        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
2292 +
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 - 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 +            rs[1].assertValue(inc(v1));
2311 +        } catch (CompletionException ok) {
2312 +            checkCompletedWithWrappedCancellationException(h1);
2313 +            rs[1].assertNotInvoked();
2314 +        }
2315 +        try {
2316 +            assertEquals(inc(v1), h2.join());
2317 +            rs[2].assertValue(inc(v1));
2318 +        } catch (CompletionException ok) {
2319 +            checkCompletedWithWrappedCancellationException(h2);
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 +
2330 +        checkCompletedNormally(f, v1);
2331 +        checkCancelled(g);
2332 +    }}
2333 +
2334      /**
2335       * applyToEither result completes exceptionally if action does
2336       */
# Line 1957 | Line 2445 | public class CompletableFutureTest exten
2445          rs[0].assertNotInvoked();
2446          rs[1].assertNotInvoked();
2447          f.completeExceptionally(ex);
2448 <        checkCompletedWithWrappedCFException(h0, ex);
2449 <        checkCompletedWithWrappedCFException(h1, 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 <        checkCompletedWithWrappedCFException(h2, ex);
2453 <        checkCompletedWithWrappedCFException(h3, ex);
2452 >        checkCompletedWithWrappedException(h2, ex);
2453 >        checkCompletedWithWrappedException(h3, ex);
2454  
2455          g.complete(v1);
2456  
# Line 1973 | Line 2461 | public class CompletableFutureTest exten
2461              assertNull(h4.join());
2462              rs[4].assertValue(v1);
2463          } catch (CompletionException ok) {
2464 <            checkCompletedWithWrappedCFException(h4, ex);
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 <            checkCompletedWithWrappedCFException(h5, ex);
2471 >            checkCompletedWithWrappedException(h5, ex);
2472              rs[5].assertNotInvoked();
2473          }
2474  
2475 <        checkCompletedWithWrappedCFException(f, ex);
2475 >        checkCompletedExceptionally(f, ex);
2476          checkCompletedNormally(g, v1);
2477 <        checkCompletedWithWrappedCFException(h0, ex);
2478 <        checkCompletedWithWrappedCFException(h1, ex);
2479 <        checkCompletedWithWrappedCFException(h2, ex);
2480 <        checkCompletedWithWrappedCFException(h3, ex);
2481 <        checkCompletedWithWrappedCFException(h4, 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<>();
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 +        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 - both source completions available
2504 +        try {
2505 +            assertEquals(null, h0.join());
2506 +            rs[0].assertValue(v1);
2507 +        } catch (CompletionException ok) {
2508 +            checkCompletedWithWrappedException(h0, ex);
2509 +            rs[0].assertNotInvoked();
2510 +        }
2511 +        try {
2512 +            assertEquals(null, h1.join());
2513 +            rs[1].assertValue(v1);
2514 +        } catch (CompletionException ok) {
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 +
2533 +        checkCompletedNormally(f, v1);
2534 +        checkCompletedExceptionally(g, ex);
2535 +    }}
2536 +
2537      /**
2538       * acceptEither result completes exceptionally if either source cancelled
2539       */
# Line 2095 | Line 2635 | public class CompletableFutureTest exten
2635       * runAfterEither result completes normally after normal completion
2636       * of either source
2637       */
2638 <    public void testRunAfterEither_normalCompletion1() {
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 +        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(h, null);
2656 <        r.assertInvoked();
2657 <        g.complete(v2);
2658 <
2659 <        checkCompletedNormally(f, v1);
2660 <        checkCompletedNormally(g, v2);
2661 <        checkCompletedNormally(h, null);
2662 <        r.assertInvoked();
2663 <    }}
2664 <
2119 <    public void testRunAfterEither_normalCompletion2() {
2120 <        for (ExecutionMode m : ExecutionMode.values())
2121 <        for (Integer v1 : new Integer[] { 1, null })
2122 <        for (Integer v2 : new Integer[] { 2, null })
2123 <    {
2124 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2125 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2126 <        final Noop r = new Noop(m);
2127 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
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  
2666          g.complete(v2);
2130 –        checkCompletedNormally(h, null);
2131 –        r.assertInvoked();
2132 –        f.complete(v1);
2133 –
2134 –        checkCompletedNormally(f, v1);
2135 –        checkCompletedNormally(g, v2);
2136 –        checkCompletedNormally(h, null);
2137 –        r.assertInvoked();
2138 –        }}
2139 –
2140 –    public void testRunAfterEither_normalCompletion3() {
2141 –        for (ExecutionMode m : ExecutionMode.values())
2142 –        for (Integer v1 : new Integer[] { 1, null })
2143 –        for (Integer v2 : new Integer[] { 2, null })
2144 –    {
2145 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2146 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2147 –        final Noop r = new Noop(m);
2667  
2668 <        f.complete(v1);
2669 <        g.complete(v2);
2151 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2668 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2669 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2670  
2153 –        checkCompletedNormally(h, null);
2671          checkCompletedNormally(f, v1);
2672          checkCompletedNormally(g, v2);
2673 <        r.assertInvoked();
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() {
2164 <        for (ExecutionMode m : ExecutionMode.values())
2165 <        for (Integer v1 : new Integer[] { 1, null })
2166 <    {
2167 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2168 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2169 <        final Noop r = new Noop(m);
2170 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2171 <        final CFException ex = new CFException();
2172 <
2173 <        f.completeExceptionally(ex);
2174 <        checkCompletedWithWrappedCFException(h, ex);
2175 <        g.complete(v1);
2176 <
2177 <        r.assertNotInvoked();
2178 <        checkCompletedNormally(g, v1);
2179 <        checkCompletedWithWrappedCFException(f, ex);
2180 <        checkCompletedWithWrappedCFException(h, ex);
2181 <    }}
2182 <
2183 <    public void testRunAfterEither_exceptionalCompletion2() {
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<>();
2189 –        final Noop r = new Noop(m);
2190 –        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 <        g.completeExceptionally(ex);
2697 <        checkCompletedWithWrappedCFException(h, ex);
2698 <        f.complete(v1);
2699 <
2700 <        r.assertNotInvoked();
2701 <        checkCompletedNormally(f, v1);
2702 <        checkCompletedWithWrappedCFException(g, ex);
2703 <        checkCompletedWithWrappedCFException(h, ex);
2704 <    }}
2705 <
2706 <    public void testRunAfterEither_exceptionalCompletion3() {
2707 <        for (ExecutionMode m : ExecutionMode.values())
2708 <        for (Integer v1 : new Integer[] { 1, null })
2206 <    {
2207 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2208 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2209 <        final Noop r = new Noop(m);
2210 <        final CFException ex = new CFException();
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 <        g.completeExceptionally(ex);
2213 <        f.complete(v1);
2214 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2710 >        assertTrue(g.complete(v1));
2711  
2712 <        // unspecified behavior
2713 <        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 <            r.assertInvoked();
2716 >            assertNull(h4.join());
2717 >            rs[4].assertInvoked();
2718          } catch (CompletionException ok) {
2719 <            checkCompletedWithWrappedCFException(h, ex);
2720 <            r.assertNotInvoked();
2719 >            checkCompletedWithWrappedException(h4, ex);
2720 >            rs[4].assertNotInvoked();
2721          }
2225 –
2226 –        checkCompletedWithWrappedCFException(g, ex);
2227 –        checkCompletedNormally(f, v1);
2228 –    }}
2229 –
2230 –    public void testRunAfterEither_exceptionalCompletion4() {
2231 –        for (ExecutionMode m : ExecutionMode.values())
2232 –        for (Integer v1 : new Integer[] { 1, null })
2233 –    {
2234 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2235 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2236 –        final Noop r = new Noop(m);
2237 –        final CFException ex = new CFException();
2238 –
2239 –        f.completeExceptionally(ex);
2240 –        g.complete(v1);
2241 –        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2242 –
2243 –        // unspecified behavior
2244 –        Integer v;
2722          try {
2723 <            assertNull(h.join());
2724 <            r.assertInvoked();
2723 >            assertNull(h5.join());
2724 >            rs[5].assertInvoked();
2725          } catch (CompletionException ok) {
2726 <            checkCompletedWithWrappedCFException(h, ex);
2727 <            r.assertNotInvoked();
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 <    /**
2258 <     * runAfterEither result completes exceptionally if action does
2259 <     */
2260 <    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 })
2263 –        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  
2287 –        g.complete(v2);
2288 –        checkCompletedWithWrappedCFException(h);
2289 –        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() {
2298 <        for (ExecutionMode m : ExecutionMode.values())
2299 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2300 <        for (Integer v1 : new Integer[] { 1, null })
2301 <    {
2302 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2303 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2304 <        final Noop r = new Noop(m);
2305 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2306 <
2307 <        assertTrue(f.cancel(mayInterruptIfRunning));
2308 <        checkCompletedWithWrappedCancellationException(h);
2309 <        g.complete(v1);
2310 <
2311 <        checkCancelled(f);
2312 <        r.assertNotInvoked();
2313 <        checkCompletedNormally(g, v1);
2314 <        checkCompletedWithWrappedCancellationException(h);
2315 <    }}
2316 <
2317 <    public void testRunAfterEither_sourceCancelled2() {
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);
2802 >        final Noop[] rs = new Noop[6];
2803 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2804  
2805 <        assertTrue(g.cancel(mayInterruptIfRunning));
2806 <        checkCompletedWithWrappedCancellationException(h);
2807 <        f.complete(v1);
2808 <
2809 <        checkCancelled(g);
2810 <        r.assertNotInvoked();
2811 <        checkCompletedNormally(f, v1);
2812 <        checkCompletedWithWrappedCancellationException(h);
2813 <    }}
2814 <
2815 <    public void testRunAfterEither_sourceCancelled3() {
2816 <        for (ExecutionMode m : ExecutionMode.values())
2817 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2340 <        for (Integer v1 : new Integer[] { 1, null })
2341 <    {
2342 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2343 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2344 <        final Noop r = new Noop(m);
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.cancel(mayInterruptIfRunning));
2347 <        f.complete(v1);
2348 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2819 >        assertTrue(g.complete(v1));
2820  
2821 <        // unspecified behavior
2822 <        Integer v;
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(h4.join());
2826 >            rs[4].assertInvoked();
2827 >        } catch (CompletionException ok) {
2828 >            checkCompletedWithWrappedCancellationException(h4);
2829 >            rs[4].assertNotInvoked();
2830 >        }
2831          try {
2832 <            assertNull(h.join());
2833 <            r.assertInvoked();
2832 >            assertNull(h5.join());
2833 >            rs[5].assertInvoked();
2834          } catch (CompletionException ok) {
2835 <            checkCompletedWithWrappedCancellationException(h);
2836 <            r.assertNotInvoked();
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())
2366 –        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 <            r.assertInvoked();
2870 <        } catch (CompletionException ok) {
2871 <            checkCompletedWithWrappedCancellationException(h);
2872 <            r.assertNotInvoked();
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 2398 | 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 <        r.assertInvoked();
2898 >        r.assertValue(v1);
2899      }}
2900  
2901      /**
# Line 2422 | 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);
2916 >        checkCompletedWithWrappedException(g, ex);
2917 >        checkCompletedExceptionally(f, ex);
2918          r.assertNotInvoked();
2919      }}
2920  
# Line 2438 | 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 2467 | 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 2483 | 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 2500 | 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 2516 | 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 2547 | 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 >            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(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 <            for (int i = 0; i < k; ++i)
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 = 0; i < k; ++i) {
3166 <                fs[i].completeExceptionally(new CFException());
3167 <                checkCompletedWithWrappedCFException(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 2568 | 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;
2571 –        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 2665 | 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 2679 | 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
2684 <     * source result.
3303 >     * newIncompleteFuture returns an incomplete CompletableFuture
3304       */
3305 <    public void testWhenComplete_normalCompletion1() {
2687 <        for (ExecutionMode m : ExecutionMode.values())
2688 <        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,
2696 <             (Integer x, Throwable t) -> {
2697 <                threadAssertSame(x, v1);
2698 <                threadAssertNull(t);
2699 <                a.getAndIncrement();
2700 <            });
2701 <        if (createIncomplete) f.complete(v1);
2702 <
2703 <        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
2710 <     * 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);
2721 <        final CompletableFuture<Integer> g = m.whenComplete
2722 <            (f,
2723 <             (Integer x, Throwable t) -> {
2724 <                threadAssertNull(x);
2725 <                threadAssertSame(t, ex);
2726 <                a.getAndIncrement();
2727 <            });
2728 <        if (createIncomplete) f.completeExceptionally(ex);
2729 <        checkCompletedWithWrappedCFException(f, ex);
2730 <        checkCompletedWithWrappedCFException(g, ex);
2731 <        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
2736 <     * 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);
2750 <                threadAssertTrue(t instanceof CancellationException);
2751 <                a.getAndIncrement();
2752 <            });
2753 <        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
2763 <     * 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) -> {
2777 <                threadAssertSame(x, v1);
2778 <                threadAssertNull(t);
2779 <                a.getAndIncrement();
2780 <                throw ex;
2781 <            });
2782 <        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
2790 <     * a source completion that also throws an exception, the source
2791 <     * 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())
2796 –        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();
2801 <        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
2805 <            (f,
2806 <             (Integer x, Throwable t) -> {
2807 <                threadAssertSame(t, ex1);
2808 <                threadAssertNull(x);
2809 <                a.getAndIncrement();
2810 <                throw ex2;
2811 <            });
2812 <        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