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.68 by jsr166, Fri Jun 6 19:35:54 2014 UTC vs.
Revision 1.141 by jsr166, Tue Mar 29 04:42:54 2016 UTC

# Line 5 | Line 5
5   * http://creativecommons.org/publicdomain/zero/1.0/
6   */
7  
8 < import junit.framework.*;
8 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
9 > import static java.util.concurrent.TimeUnit.SECONDS;
10 > import static java.util.concurrent.CompletableFuture.completedFuture;
11 > import static java.util.concurrent.CompletableFuture.failedFuture;
12 >
13 > import java.lang.reflect.Method;
14 > import java.lang.reflect.Modifier;
15 >
16 > import java.util.stream.Collectors;
17 > import java.util.stream.Stream;
18 >
19 > import java.util.ArrayList;
20 > import java.util.Arrays;
21 > import java.util.List;
22 > import java.util.Objects;
23 > import java.util.Set;
24   import java.util.concurrent.Callable;
10 – import java.util.concurrent.Executor;
11 – import java.util.concurrent.ExecutorService;
12 – import java.util.concurrent.Executors;
25   import java.util.concurrent.CancellationException;
14 – import java.util.concurrent.CountDownLatch;
15 – import java.util.concurrent.ExecutionException;
16 – import java.util.concurrent.Future;
26   import java.util.concurrent.CompletableFuture;
27   import java.util.concurrent.CompletionException;
28   import java.util.concurrent.CompletionStage;
29 + import java.util.concurrent.ExecutionException;
30 + import java.util.concurrent.Executor;
31   import java.util.concurrent.ForkJoinPool;
32   import java.util.concurrent.ForkJoinTask;
33   import java.util.concurrent.TimeoutException;
34 + import java.util.concurrent.TimeUnit;
35   import java.util.concurrent.atomic.AtomicInteger;
36 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
25 < import static java.util.concurrent.TimeUnit.SECONDS;
26 < import java.util.*;
27 < import java.util.function.Supplier;
28 < import java.util.function.Consumer;
36 > import java.util.concurrent.atomic.AtomicReference;
37   import java.util.function.BiConsumer;
30 – import java.util.function.Function;
38   import java.util.function.BiFunction;
39 + import java.util.function.Consumer;
40 + import java.util.function.Function;
41 + import java.util.function.Predicate;
42 + import java.util.function.Supplier;
43 +
44 + import junit.framework.AssertionFailedError;
45 + import junit.framework.Test;
46 + import junit.framework.TestSuite;
47  
48   public class CompletableFutureTest extends JSR166TestCase {
49  
50      public static void main(String[] args) {
51 <        junit.textui.TestRunner.run(suite());
51 >        main(suite(), args);
52      }
53      public static Test suite() {
54          return new TestSuite(CompletableFutureTest.class);
# Line 44 | Line 59 | public class CompletableFutureTest exten
59      void checkIncomplete(CompletableFuture<?> f) {
60          assertFalse(f.isDone());
61          assertFalse(f.isCancelled());
62 <        assertTrue(f.toString().contains("[Not completed]"));
62 >        assertTrue(f.toString().contains("Not completed"));
63          try {
64              assertNull(f.getNow(null));
65          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 57 | Line 72 | public class CompletableFutureTest exten
72      }
73  
74      <T> void checkCompletedNormally(CompletableFuture<T> f, T value) {
75 <        try {
76 <            assertEquals(value, f.get(LONG_DELAY_MS, MILLISECONDS));
62 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
75 >        checkTimedGet(f, value);
76 >
77          try {
78              assertEquals(value, f.join());
79          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 75 | Line 89 | public class CompletableFutureTest exten
89          assertTrue(f.toString().contains("[Completed normally]"));
90      }
91  
92 <    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
93 <        try {
94 <            f.get(LONG_DELAY_MS, MILLISECONDS);
95 <            shouldThrow();
96 <        } catch (ExecutionException success) {
97 <            assertTrue(success.getCause() instanceof CFException);
98 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
99 <        try {
100 <            f.join();
101 <            shouldThrow();
102 <        } catch (CompletionException success) {
103 <            assertTrue(success.getCause() instanceof CFException);
104 <        }
105 <        try {
106 <            f.getNow(null);
107 <            shouldThrow();
108 <        } catch (CompletionException success) {
95 <            assertTrue(success.getCause() instanceof CFException);
92 >    /**
93 >     * Returns the "raw" internal exceptional completion of f,
94 >     * without any additional wrapping with CompletionException.
95 >     */
96 >    <U> Throwable exceptionalCompletion(CompletableFuture<U> f) {
97 >        // handle (and whenComplete) can distinguish between "direct"
98 >        // and "wrapped" exceptional completion
99 >        return f.handle((U u, Throwable t) -> t).join();
100 >    }
101 >
102 >    void checkCompletedExceptionally(CompletableFuture<?> f,
103 >                                     boolean wrapped,
104 >                                     Consumer<Throwable> checker) {
105 >        Throwable cause = exceptionalCompletion(f);
106 >        if (wrapped) {
107 >            assertTrue(cause instanceof CompletionException);
108 >            cause = cause.getCause();
109          }
110 <        try {
98 <            f.get();
99 <            shouldThrow();
100 <        } catch (ExecutionException success) {
101 <            assertTrue(success.getCause() instanceof CFException);
102 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
103 <        assertTrue(f.isDone());
104 <        assertFalse(f.isCancelled());
105 <        assertTrue(f.toString().contains("[Completed exceptionally]"));
106 <    }
110 >        checker.accept(cause);
111  
112 <    void checkCompletedWithWrappedCFException(CompletableFuture<?> f,
109 <                                              CFException ex) {
112 >        long startTime = System.nanoTime();
113          try {
114              f.get(LONG_DELAY_MS, MILLISECONDS);
115              shouldThrow();
116          } catch (ExecutionException success) {
117 <            assertSame(ex, success.getCause());
117 >            assertSame(cause, success.getCause());
118          } catch (Throwable fail) { threadUnexpectedException(fail); }
119 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
120 +
121          try {
122              f.join();
123              shouldThrow();
124          } catch (CompletionException success) {
125 <            assertSame(ex, success.getCause());
126 <        }
125 >            assertSame(cause, success.getCause());
126 >        } catch (Throwable fail) { threadUnexpectedException(fail); }
127 >
128          try {
129              f.getNow(null);
130              shouldThrow();
131          } catch (CompletionException success) {
132 <            assertSame(ex, success.getCause());
133 <        }
132 >            assertSame(cause, success.getCause());
133 >        } catch (Throwable fail) { threadUnexpectedException(fail); }
134 >
135          try {
136              f.get();
137              shouldThrow();
138          } catch (ExecutionException success) {
139 <            assertSame(ex, success.getCause());
139 >            assertSame(cause, success.getCause());
140          } catch (Throwable fail) { threadUnexpectedException(fail); }
141 <        assertTrue(f.isDone());
141 >
142          assertFalse(f.isCancelled());
143 +        assertTrue(f.isDone());
144 +        assertTrue(f.isCompletedExceptionally());
145          assertTrue(f.toString().contains("[Completed exceptionally]"));
146      }
147  
148 +    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
149 +        checkCompletedExceptionally(f, true,
150 +            (t) -> assertTrue(t instanceof CFException));
151 +    }
152 +
153 +    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
154 +        checkCompletedExceptionally(f, true,
155 +            (t) -> assertTrue(t instanceof CancellationException));
156 +    }
157 +
158 +    void checkCompletedWithTimeoutException(CompletableFuture<?> f) {
159 +        checkCompletedExceptionally(f, false,
160 +            (t) -> assertTrue(t instanceof TimeoutException));
161 +    }
162 +
163 +    void checkCompletedWithWrappedException(CompletableFuture<?> f,
164 +                                            Throwable ex) {
165 +        checkCompletedExceptionally(f, true, (t) -> assertSame(t, ex));
166 +    }
167 +
168 +    void checkCompletedExceptionally(CompletableFuture<?> f, Throwable ex) {
169 +        checkCompletedExceptionally(f, false, (t) -> assertSame(t, ex));
170 +    }
171 +
172      void checkCancelled(CompletableFuture<?> f) {
173 +        long startTime = System.nanoTime();
174          try {
175              f.get(LONG_DELAY_MS, MILLISECONDS);
176              shouldThrow();
177          } catch (CancellationException success) {
178          } catch (Throwable fail) { threadUnexpectedException(fail); }
179 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
180 +
181          try {
182              f.join();
183              shouldThrow();
# Line 155 | Line 191 | public class CompletableFutureTest exten
191              shouldThrow();
192          } catch (CancellationException success) {
193          } catch (Throwable fail) { threadUnexpectedException(fail); }
158 –        assertTrue(f.isDone());
159 –        assertTrue(f.isCompletedExceptionally());
160 –        assertTrue(f.isCancelled());
161 –        assertTrue(f.toString().contains("[Completed exceptionally]"));
162 –    }
194  
195 <    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
196 <        try {
166 <            f.get(LONG_DELAY_MS, MILLISECONDS);
167 <            shouldThrow();
168 <        } catch (ExecutionException success) {
169 <            assertTrue(success.getCause() instanceof CancellationException);
170 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
171 <        try {
172 <            f.join();
173 <            shouldThrow();
174 <        } catch (CompletionException success) {
175 <            assertTrue(success.getCause() instanceof CancellationException);
176 <        }
177 <        try {
178 <            f.getNow(null);
179 <            shouldThrow();
180 <        } catch (CompletionException success) {
181 <            assertTrue(success.getCause() instanceof CancellationException);
182 <        }
183 <        try {
184 <            f.get();
185 <            shouldThrow();
186 <        } catch (ExecutionException success) {
187 <            assertTrue(success.getCause() instanceof CancellationException);
188 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
195 >        assertTrue(exceptionalCompletion(f) instanceof CancellationException);
196 >
197          assertTrue(f.isDone());
190 –        assertFalse(f.isCancelled());
198          assertTrue(f.isCompletedExceptionally());
199 +        assertTrue(f.isCancelled());
200          assertTrue(f.toString().contains("[Completed exceptionally]"));
201      }
202  
# Line 206 | Line 214 | public class CompletableFutureTest exten
214       * isCancelled, join, get, and getNow
215       */
216      public void testComplete() {
217 +        for (Integer v1 : new Integer[] { 1, null })
218 +    {
219          CompletableFuture<Integer> f = new CompletableFuture<>();
220          checkIncomplete(f);
221 <        f.complete(one);
222 <        checkCompletedNormally(f, one);
223 <    }
221 >        assertTrue(f.complete(v1));
222 >        assertFalse(f.complete(v1));
223 >        checkCompletedNormally(f, v1);
224 >    }}
225  
226      /**
227       * completeExceptionally completes exceptionally, as indicated by
# Line 218 | Line 229 | public class CompletableFutureTest exten
229       */
230      public void testCompleteExceptionally() {
231          CompletableFuture<Integer> f = new CompletableFuture<>();
232 +        CFException ex = new CFException();
233          checkIncomplete(f);
234 <        f.completeExceptionally(new CFException());
235 <        checkCompletedWithWrappedCFException(f);
234 >        f.completeExceptionally(ex);
235 >        checkCompletedExceptionally(f, ex);
236      }
237  
238      /**
# Line 228 | Line 240 | public class CompletableFutureTest exten
240       * methods isDone, isCancelled, join, get, and getNow
241       */
242      public void testCancel() {
243 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
244 +    {
245          CompletableFuture<Integer> f = new CompletableFuture<>();
246          checkIncomplete(f);
247 <        assertTrue(f.cancel(true));
247 >        assertTrue(f.cancel(mayInterruptIfRunning));
248 >        assertTrue(f.cancel(mayInterruptIfRunning));
249 >        assertTrue(f.cancel(!mayInterruptIfRunning));
250          checkCancelled(f);
251 <    }
251 >    }}
252  
253      /**
254       * obtrudeValue forces completion with given value
# Line 240 | Line 256 | public class CompletableFutureTest exten
256      public void testObtrudeValue() {
257          CompletableFuture<Integer> f = new CompletableFuture<>();
258          checkIncomplete(f);
259 <        f.complete(one);
259 >        assertTrue(f.complete(one));
260          checkCompletedNormally(f, one);
261          f.obtrudeValue(three);
262          checkCompletedNormally(f, three);
# Line 261 | Line 277 | public class CompletableFutureTest exten
277       * obtrudeException forces completion with given exception
278       */
279      public void testObtrudeException() {
280 <        CompletableFuture<Integer> f = new CompletableFuture<>();
281 <        checkIncomplete(f);
282 <        f.complete(one);
283 <        checkCompletedNormally(f, one);
284 <        f.obtrudeException(new CFException());
269 <        checkCompletedWithWrappedCFException(f);
280 >        for (Integer v1 : new Integer[] { 1, null })
281 >    {
282 >        CFException ex;
283 >        CompletableFuture<Integer> f;
284 >
285          f = new CompletableFuture<>();
286 <        f.obtrudeException(new CFException());
287 <        checkCompletedWithWrappedCFException(f);
286 >        assertTrue(f.complete(v1));
287 >        for (int i = 0; i < 2; i++) {
288 >            f.obtrudeException(ex = new CFException());
289 >            checkCompletedExceptionally(f, ex);
290 >        }
291 >
292          f = new CompletableFuture<>();
293 +        for (int i = 0; i < 2; i++) {
294 +            f.obtrudeException(ex = new CFException());
295 +            checkCompletedExceptionally(f, ex);
296 +        }
297 +
298 +        f = new CompletableFuture<>();
299 +        f.completeExceptionally(ex = new CFException());
300 +        f.obtrudeValue(v1);
301 +        checkCompletedNormally(f, v1);
302 +        f.obtrudeException(ex = new CFException());
303 +        checkCompletedExceptionally(f, ex);
304          f.completeExceptionally(new CFException());
305 <        f.obtrudeValue(four);
306 <        checkCompletedNormally(f, four);
307 <        f.obtrudeException(new CFException());
308 <        checkCompletedWithWrappedCFException(f);
279 <    }
305 >        checkCompletedExceptionally(f, ex);
306 >        assertFalse(f.complete(v1));
307 >        checkCompletedExceptionally(f, ex);
308 >    }}
309  
310      /**
311       * getNumberOfDependents returns number of dependent tasks
312       */
313      public void testGetNumberOfDependents() {
314 +        for (ExecutionMode m : ExecutionMode.values())
315 +        for (Integer v1 : new Integer[] { 1, null })
316 +    {
317          CompletableFuture<Integer> f = new CompletableFuture<>();
318          assertEquals(0, f.getNumberOfDependents());
319 <        CompletableFuture g = f.thenRun(new Noop(ExecutionMode.DEFAULT));
319 >        final CompletableFuture<Void> g = m.thenRun(f, new Noop(m));
320          assertEquals(1, f.getNumberOfDependents());
321          assertEquals(0, g.getNumberOfDependents());
322 <        CompletableFuture h = f.thenRun(new Noop(ExecutionMode.DEFAULT));
322 >        final CompletableFuture<Void> h = m.thenRun(f, new Noop(m));
323          assertEquals(2, f.getNumberOfDependents());
324 <        f.complete(1);
324 >        assertEquals(0, h.getNumberOfDependents());
325 >        assertTrue(f.complete(v1));
326          checkCompletedNormally(g, null);
327 +        checkCompletedNormally(h, null);
328          assertEquals(0, f.getNumberOfDependents());
329          assertEquals(0, g.getNumberOfDependents());
330 <    }
330 >        assertEquals(0, h.getNumberOfDependents());
331 >    }}
332  
333      /**
334       * toString indicates current completion state
# Line 304 | Line 339 | public class CompletableFutureTest exten
339          f = new CompletableFuture<String>();
340          assertTrue(f.toString().contains("[Not completed]"));
341  
342 <        f.complete("foo");
342 >        assertTrue(f.complete("foo"));
343          assertTrue(f.toString().contains("[Completed normally]"));
344  
345          f = new CompletableFuture<String>();
346 <        f.completeExceptionally(new IndexOutOfBoundsException());
346 >        assertTrue(f.completeExceptionally(new IndexOutOfBoundsException()));
347          assertTrue(f.toString().contains("[Completed exceptionally]"));
348 +
349 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
350 +            f = new CompletableFuture<String>();
351 +            assertTrue(f.cancel(mayInterruptIfRunning));
352 +            assertTrue(f.toString().contains("[Completed exceptionally]"));
353 +        }
354      }
355  
356      /**
# Line 477 | Line 518 | public class CompletableFutureTest exten
518          }
519      }
520  
480 –
521      class CompletableFutureInc extends CheckedIntegerAction
522          implements Function<Integer, CompletableFuture<Integer>>
523      {
# Line 486 | Line 526 | public class CompletableFutureTest exten
526              invoked();
527              value = x;
528              CompletableFuture<Integer> f = new CompletableFuture<>();
529 <            f.complete(inc(x));
529 >            assertTrue(f.complete(inc(x)));
530              return f;
531          }
532      }
# Line 516 | Line 556 | public class CompletableFutureTest exten
556          }
557      }
558  
559 +    static final boolean defaultExecutorIsCommonPool
560 +        = ForkJoinPool.getCommonPoolParallelism() > 1;
561 +
562      /**
563       * Permits the testing of parallel code for the 3 different
564       * execution modes without copy/pasting all the test methods.
565       */
566      enum ExecutionMode {
567 <        DEFAULT {
567 >        SYNC {
568              public void checkExecutionMode() {
569                  assertFalse(ThreadExecutor.startedCurrentThread());
570                  assertNull(ForkJoinTask.getPool());
# Line 597 | Line 640 | public class CompletableFutureTest exten
640  
641          ASYNC {
642              public void checkExecutionMode() {
643 <                assertSame(ForkJoinPool.commonPool(),
644 <                           ForkJoinTask.getPool());
643 >                assertEquals(defaultExecutorIsCommonPool,
644 >                             (ForkJoinPool.commonPool() == ForkJoinTask.getPool()));
645              }
646              public CompletableFuture<Void> runAsync(Runnable a) {
647                  return CompletableFuture.runAsync(a);
# Line 794 | Line 837 | public class CompletableFutureTest exten
837      {
838          final AtomicInteger a = new AtomicInteger(0);
839          final CompletableFuture<Integer> f = new CompletableFuture<>();
840 <        if (!createIncomplete) f.complete(v1);
840 >        if (!createIncomplete) assertTrue(f.complete(v1));
841          final CompletableFuture<Integer> g = f.exceptionally
842              ((Throwable t) -> {
800 –                // Should not be called
843                  a.getAndIncrement();
844 <                throw new AssertionError();
844 >                threadFail("should not be called");
845 >                return null;            // unreached
846              });
847 <        if (createIncomplete) f.complete(v1);
847 >        if (createIncomplete) assertTrue(f.complete(v1));
848  
849          checkCompletedNormally(g, v1);
850          checkCompletedNormally(f, v1);
851          assertEquals(0, a.get());
852      }}
853  
811 –
854      /**
855       * exceptionally action completes with function value on source
856       * exception
# Line 823 | Line 865 | public class CompletableFutureTest exten
865          if (!createIncomplete) f.completeExceptionally(ex);
866          final CompletableFuture<Integer> g = f.exceptionally
867              ((Throwable t) -> {
868 <                ExecutionMode.DEFAULT.checkExecutionMode();
868 >                ExecutionMode.SYNC.checkExecutionMode();
869                  threadAssertSame(t, ex);
870                  a.getAndIncrement();
871                  return v1;
# Line 834 | Line 876 | public class CompletableFutureTest exten
876          assertEquals(1, a.get());
877      }}
878  
879 +    /**
880 +     * If an "exceptionally action" throws an exception, it completes
881 +     * exceptionally with that exception
882 +     */
883      public void testExceptionally_exceptionalCompletionActionFailed() {
884          for (boolean createIncomplete : new boolean[] { true, false })
839 –        for (Integer v1 : new Integer[] { 1, null })
885      {
886          final AtomicInteger a = new AtomicInteger(0);
887          final CFException ex1 = new CFException();
# Line 845 | Line 890 | public class CompletableFutureTest exten
890          if (!createIncomplete) f.completeExceptionally(ex1);
891          final CompletableFuture<Integer> g = f.exceptionally
892              ((Throwable t) -> {
893 <                ExecutionMode.DEFAULT.checkExecutionMode();
893 >                ExecutionMode.SYNC.checkExecutionMode();
894 >                threadAssertSame(t, ex1);
895 >                a.getAndIncrement();
896 >                throw ex2;
897 >            });
898 >        if (createIncomplete) f.completeExceptionally(ex1);
899 >
900 >        checkCompletedWithWrappedException(g, ex2);
901 >        checkCompletedExceptionally(f, ex1);
902 >        assertEquals(1, a.get());
903 >    }}
904 >
905 >    /**
906 >     * whenComplete action executes on normal completion, propagating
907 >     * source result.
908 >     */
909 >    public void testWhenComplete_normalCompletion() {
910 >        for (ExecutionMode m : ExecutionMode.values())
911 >        for (boolean createIncomplete : new boolean[] { true, false })
912 >        for (Integer v1 : new Integer[] { 1, null })
913 >    {
914 >        final AtomicInteger a = new AtomicInteger(0);
915 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
916 >        if (!createIncomplete) assertTrue(f.complete(v1));
917 >        final CompletableFuture<Integer> g = m.whenComplete
918 >            (f,
919 >             (Integer result, Throwable t) -> {
920 >                m.checkExecutionMode();
921 >                threadAssertSame(result, v1);
922 >                threadAssertNull(t);
923 >                a.getAndIncrement();
924 >            });
925 >        if (createIncomplete) assertTrue(f.complete(v1));
926 >
927 >        checkCompletedNormally(g, v1);
928 >        checkCompletedNormally(f, v1);
929 >        assertEquals(1, a.get());
930 >    }}
931 >
932 >    /**
933 >     * whenComplete action executes on exceptional completion, propagating
934 >     * source result.
935 >     */
936 >    public void testWhenComplete_exceptionalCompletion() {
937 >        for (ExecutionMode m : ExecutionMode.values())
938 >        for (boolean createIncomplete : new boolean[] { true, false })
939 >    {
940 >        final AtomicInteger a = new AtomicInteger(0);
941 >        final CFException ex = new CFException();
942 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
943 >        if (!createIncomplete) f.completeExceptionally(ex);
944 >        final CompletableFuture<Integer> g = m.whenComplete
945 >            (f,
946 >             (Integer result, Throwable t) -> {
947 >                m.checkExecutionMode();
948 >                threadAssertNull(result);
949 >                threadAssertSame(t, ex);
950 >                a.getAndIncrement();
951 >            });
952 >        if (createIncomplete) f.completeExceptionally(ex);
953 >
954 >        checkCompletedWithWrappedException(g, ex);
955 >        checkCompletedExceptionally(f, ex);
956 >        assertEquals(1, a.get());
957 >    }}
958 >
959 >    /**
960 >     * whenComplete action executes on cancelled source, propagating
961 >     * CancellationException.
962 >     */
963 >    public void testWhenComplete_sourceCancelled() {
964 >        for (ExecutionMode m : ExecutionMode.values())
965 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
966 >        for (boolean createIncomplete : new boolean[] { true, false })
967 >    {
968 >        final AtomicInteger a = new AtomicInteger(0);
969 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
970 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
971 >        final CompletableFuture<Integer> g = m.whenComplete
972 >            (f,
973 >             (Integer result, Throwable t) -> {
974 >                m.checkExecutionMode();
975 >                threadAssertNull(result);
976 >                threadAssertTrue(t instanceof CancellationException);
977 >                a.getAndIncrement();
978 >            });
979 >        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
980 >
981 >        checkCompletedWithWrappedCancellationException(g);
982 >        checkCancelled(f);
983 >        assertEquals(1, a.get());
984 >    }}
985 >
986 >    /**
987 >     * If a whenComplete action throws an exception when triggered by
988 >     * a normal completion, it completes exceptionally
989 >     */
990 >    public void testWhenComplete_sourceCompletedNormallyActionFailed() {
991 >        for (boolean createIncomplete : new boolean[] { true, false })
992 >        for (ExecutionMode m : ExecutionMode.values())
993 >        for (Integer v1 : new Integer[] { 1, null })
994 >    {
995 >        final AtomicInteger a = new AtomicInteger(0);
996 >        final CFException ex = new CFException();
997 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
998 >        if (!createIncomplete) assertTrue(f.complete(v1));
999 >        final CompletableFuture<Integer> g = m.whenComplete
1000 >            (f,
1001 >             (Integer result, Throwable t) -> {
1002 >                m.checkExecutionMode();
1003 >                threadAssertSame(result, v1);
1004 >                threadAssertNull(t);
1005 >                a.getAndIncrement();
1006 >                throw ex;
1007 >            });
1008 >        if (createIncomplete) assertTrue(f.complete(v1));
1009 >
1010 >        checkCompletedWithWrappedException(g, ex);
1011 >        checkCompletedNormally(f, v1);
1012 >        assertEquals(1, a.get());
1013 >    }}
1014 >
1015 >    /**
1016 >     * If a whenComplete action throws an exception when triggered by
1017 >     * a source completion that also throws an exception, the source
1018 >     * exception takes precedence (unlike handle)
1019 >     */
1020 >    public void testWhenComplete_sourceFailedActionFailed() {
1021 >        for (boolean createIncomplete : new boolean[] { true, false })
1022 >        for (ExecutionMode m : ExecutionMode.values())
1023 >    {
1024 >        final AtomicInteger a = new AtomicInteger(0);
1025 >        final CFException ex1 = new CFException();
1026 >        final CFException ex2 = new CFException();
1027 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1028 >
1029 >        if (!createIncomplete) f.completeExceptionally(ex1);
1030 >        final CompletableFuture<Integer> g = m.whenComplete
1031 >            (f,
1032 >             (Integer result, Throwable t) -> {
1033 >                m.checkExecutionMode();
1034                  threadAssertSame(t, ex1);
1035 +                threadAssertNull(result);
1036                  a.getAndIncrement();
1037                  throw ex2;
1038              });
1039          if (createIncomplete) f.completeExceptionally(ex1);
1040  
1041 <        checkCompletedWithWrappedCFException(g, ex2);
1041 >        checkCompletedWithWrappedException(g, ex1);
1042 >        checkCompletedExceptionally(f, ex1);
1043 >        if (testImplementationDetails) {
1044 >            assertEquals(1, ex1.getSuppressed().length);
1045 >            assertSame(ex2, ex1.getSuppressed()[0]);
1046 >        }
1047          assertEquals(1, a.get());
1048      }}
1049  
# Line 867 | Line 1058 | public class CompletableFutureTest exten
1058      {
1059          final CompletableFuture<Integer> f = new CompletableFuture<>();
1060          final AtomicInteger a = new AtomicInteger(0);
1061 <        if (!createIncomplete) f.complete(v1);
1061 >        if (!createIncomplete) assertTrue(f.complete(v1));
1062          final CompletableFuture<Integer> g = m.handle
1063              (f,
1064 <             (Integer x, Throwable t) -> {
1064 >             (Integer result, Throwable t) -> {
1065                  m.checkExecutionMode();
1066 <                threadAssertSame(x, v1);
1066 >                threadAssertSame(result, v1);
1067                  threadAssertNull(t);
1068                  a.getAndIncrement();
1069                  return inc(v1);
1070              });
1071 <        if (createIncomplete) f.complete(v1);
1071 >        if (createIncomplete) assertTrue(f.complete(v1));
1072  
1073          checkCompletedNormally(g, inc(v1));
1074          checkCompletedNormally(f, v1);
# Line 899 | Line 1090 | public class CompletableFutureTest exten
1090          if (!createIncomplete) f.completeExceptionally(ex);
1091          final CompletableFuture<Integer> g = m.handle
1092              (f,
1093 <             (Integer x, Throwable t) -> {
1093 >             (Integer result, Throwable t) -> {
1094                  m.checkExecutionMode();
1095 <                threadAssertNull(x);
1095 >                threadAssertNull(result);
1096                  threadAssertSame(t, ex);
1097                  a.getAndIncrement();
1098                  return v1;
# Line 909 | Line 1100 | public class CompletableFutureTest exten
1100          if (createIncomplete) f.completeExceptionally(ex);
1101  
1102          checkCompletedNormally(g, v1);
1103 <        checkCompletedWithWrappedCFException(f, ex);
1103 >        checkCompletedExceptionally(f, ex);
1104          assertEquals(1, a.get());
1105      }}
1106  
# Line 928 | Line 1119 | public class CompletableFutureTest exten
1119          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1120          final CompletableFuture<Integer> g = m.handle
1121              (f,
1122 <             (Integer x, Throwable t) -> {
1122 >             (Integer result, Throwable t) -> {
1123                  m.checkExecutionMode();
1124 <                threadAssertNull(x);
1124 >                threadAssertNull(result);
1125                  threadAssertTrue(t instanceof CancellationException);
1126                  a.getAndIncrement();
1127                  return v1;
# Line 943 | Line 1134 | public class CompletableFutureTest exten
1134      }}
1135  
1136      /**
1137 <     * handle result completes exceptionally if action does
1137 >     * If a "handle action" throws an exception when triggered by
1138 >     * a normal completion, it completes exceptionally
1139       */
1140 <    public void testHandle_sourceFailedActionFailed() {
1140 >    public void testHandle_sourceCompletedNormallyActionFailed() {
1141          for (ExecutionMode m : ExecutionMode.values())
1142          for (boolean createIncomplete : new boolean[] { true, false })
1143 +        for (Integer v1 : new Integer[] { 1, null })
1144      {
1145          final CompletableFuture<Integer> f = new CompletableFuture<>();
1146          final AtomicInteger a = new AtomicInteger(0);
1147 <        final CFException ex1 = new CFException();
1148 <        final CFException ex2 = new CFException();
956 <        if (!createIncomplete) f.completeExceptionally(ex1);
1147 >        final CFException ex = new CFException();
1148 >        if (!createIncomplete) assertTrue(f.complete(v1));
1149          final CompletableFuture<Integer> g = m.handle
1150              (f,
1151 <             (Integer x, Throwable t) -> {
1151 >             (Integer result, Throwable t) -> {
1152                  m.checkExecutionMode();
1153 <                threadAssertNull(x);
1154 <                threadAssertSame(ex1, t);
1153 >                threadAssertSame(result, v1);
1154 >                threadAssertNull(t);
1155                  a.getAndIncrement();
1156 <                throw ex2;
1156 >                throw ex;
1157              });
1158 <        if (createIncomplete) f.completeExceptionally(ex1);
1158 >        if (createIncomplete) assertTrue(f.complete(v1));
1159  
1160 <        checkCompletedWithWrappedCFException(g, ex2);
1161 <        checkCompletedWithWrappedCFException(f, ex1);
1160 >        checkCompletedWithWrappedException(g, ex);
1161 >        checkCompletedNormally(f, v1);
1162          assertEquals(1, a.get());
1163      }}
1164  
1165 <    public void testHandle_sourceCompletedNormallyActionFailed() {
1166 <        for (ExecutionMode m : ExecutionMode.values())
1165 >    /**
1166 >     * If a "handle action" throws an exception when triggered by
1167 >     * a source completion that also throws an exception, the action
1168 >     * exception takes precedence (unlike whenComplete)
1169 >     */
1170 >    public void testHandle_sourceFailedActionFailed() {
1171          for (boolean createIncomplete : new boolean[] { true, false })
1172 <        for (Integer v1 : new Integer[] { 1, null })
1172 >        for (ExecutionMode m : ExecutionMode.values())
1173      {
978 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1174          final AtomicInteger a = new AtomicInteger(0);
1175 <        final CFException ex = new CFException();
1176 <        if (!createIncomplete) f.complete(v1);
1175 >        final CFException ex1 = new CFException();
1176 >        final CFException ex2 = new CFException();
1177 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1178 >
1179 >        if (!createIncomplete) f.completeExceptionally(ex1);
1180          final CompletableFuture<Integer> g = m.handle
1181              (f,
1182 <             (Integer x, Throwable t) -> {
1182 >             (Integer result, Throwable t) -> {
1183                  m.checkExecutionMode();
1184 <                threadAssertSame(x, v1);
1185 <                threadAssertNull(t);
1184 >                threadAssertNull(result);
1185 >                threadAssertSame(ex1, t);
1186                  a.getAndIncrement();
1187 <                throw ex;
1187 >                throw ex2;
1188              });
1189 <        if (createIncomplete) f.complete(v1);
1189 >        if (createIncomplete) f.completeExceptionally(ex1);
1190  
1191 <        checkCompletedWithWrappedCFException(g, ex);
1192 <        checkCompletedNormally(f, v1);
1191 >        checkCompletedWithWrappedException(g, ex2);
1192 >        checkCompletedExceptionally(f, ex1);
1193          assertEquals(1, a.get());
1194      }}
1195  
# Line 1069 | Line 1267 | public class CompletableFutureTest exten
1267       */
1268      public void testThenRun_normalCompletion() {
1269          for (ExecutionMode m : ExecutionMode.values())
1072 –        for (boolean createIncomplete : new boolean[] { true, false })
1270          for (Integer v1 : new Integer[] { 1, null })
1271      {
1272          final CompletableFuture<Integer> f = new CompletableFuture<>();
1273 <        final Noop r = new Noop(m);
1274 <        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 <        }
1273 >        final Noop[] rs = new Noop[6];
1274 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1275  
1276 <        checkCompletedNormally(g, null);
1276 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1277 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1278 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1279 >        checkIncomplete(h0);
1280 >        checkIncomplete(h1);
1281 >        checkIncomplete(h2);
1282 >        assertTrue(f.complete(v1));
1283 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1284 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1285 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1286 >
1287 >        checkCompletedNormally(h0, null);
1288 >        checkCompletedNormally(h1, null);
1289 >        checkCompletedNormally(h2, null);
1290 >        checkCompletedNormally(h3, null);
1291 >        checkCompletedNormally(h4, null);
1292 >        checkCompletedNormally(h5, null);
1293          checkCompletedNormally(f, v1);
1294 <        r.assertInvoked();
1294 >        for (Noop r : rs) r.assertInvoked();
1295      }}
1296  
1297      /**
# Line 1092 | Line 1300 | public class CompletableFutureTest exten
1300       */
1301      public void testThenRun_exceptionalCompletion() {
1302          for (ExecutionMode m : ExecutionMode.values())
1095 –        for (boolean createIncomplete : new boolean[] { true, false })
1303      {
1304          final CFException ex = new CFException();
1305          final CompletableFuture<Integer> f = new CompletableFuture<>();
1306 <        final Noop r = new Noop(m);
1307 <        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 <        }
1306 >        final Noop[] rs = new Noop[6];
1307 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1308  
1309 <        checkCompletedWithWrappedCFException(g, ex);
1310 <        checkCompletedWithWrappedCFException(f, ex);
1311 <        r.assertNotInvoked();
1309 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1310 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1311 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1312 >        checkIncomplete(h0);
1313 >        checkIncomplete(h1);
1314 >        checkIncomplete(h2);
1315 >        assertTrue(f.completeExceptionally(ex));
1316 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1317 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1318 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1319 >
1320 >        checkCompletedWithWrappedException(h0, ex);
1321 >        checkCompletedWithWrappedException(h1, ex);
1322 >        checkCompletedWithWrappedException(h2, ex);
1323 >        checkCompletedWithWrappedException(h3, ex);
1324 >        checkCompletedWithWrappedException(h4, ex);
1325 >        checkCompletedWithWrappedException(h5, ex);
1326 >        checkCompletedExceptionally(f, ex);
1327 >        for (Noop r : rs) r.assertNotInvoked();
1328      }}
1329  
1330      /**
# Line 1114 | Line 1332 | public class CompletableFutureTest exten
1332       */
1333      public void testThenRun_sourceCancelled() {
1334          for (ExecutionMode m : ExecutionMode.values())
1117 –        for (boolean createIncomplete : new boolean[] { true, false })
1335          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1336      {
1337          final CompletableFuture<Integer> f = new CompletableFuture<>();
1338 <        final Noop r = new Noop(m);
1339 <        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 <        }
1338 >        final Noop[] rs = new Noop[6];
1339 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1340  
1341 <        checkCompletedWithWrappedCancellationException(g);
1341 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1342 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1343 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1344 >        checkIncomplete(h0);
1345 >        checkIncomplete(h1);
1346 >        checkIncomplete(h2);
1347 >        assertTrue(f.cancel(mayInterruptIfRunning));
1348 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1349 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1350 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1351 >
1352 >        checkCompletedWithWrappedCancellationException(h0);
1353 >        checkCompletedWithWrappedCancellationException(h1);
1354 >        checkCompletedWithWrappedCancellationException(h2);
1355 >        checkCompletedWithWrappedCancellationException(h3);
1356 >        checkCompletedWithWrappedCancellationException(h4);
1357 >        checkCompletedWithWrappedCancellationException(h5);
1358          checkCancelled(f);
1359 <        r.assertNotInvoked();
1359 >        for (Noop r : rs) r.assertNotInvoked();
1360      }}
1361  
1362      /**
# Line 1136 | Line 1364 | public class CompletableFutureTest exten
1364       */
1365      public void testThenRun_actionFailed() {
1366          for (ExecutionMode m : ExecutionMode.values())
1139 –        for (boolean createIncomplete : new boolean[] { true, false })
1367          for (Integer v1 : new Integer[] { 1, null })
1368      {
1369          final CompletableFuture<Integer> f = new CompletableFuture<>();
1370 <        final FailingRunnable r = new FailingRunnable(m);
1371 <        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 <        }
1370 >        final FailingRunnable[] rs = new FailingRunnable[6];
1371 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
1372  
1373 <        checkCompletedWithWrappedCFException(g);
1373 >        final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1374 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1375 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1376 >        assertTrue(f.complete(v1));
1377 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1378 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1379 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1380 >
1381 >        checkCompletedWithWrappedCFException(h0);
1382 >        checkCompletedWithWrappedCFException(h1);
1383 >        checkCompletedWithWrappedCFException(h2);
1384 >        checkCompletedWithWrappedCFException(h3);
1385 >        checkCompletedWithWrappedCFException(h4);
1386 >        checkCompletedWithWrappedCFException(h5);
1387          checkCompletedNormally(f, v1);
1388      }}
1389  
# Line 1157 | Line 1392 | public class CompletableFutureTest exten
1392       */
1393      public void testThenApply_normalCompletion() {
1394          for (ExecutionMode m : ExecutionMode.values())
1160 –        for (boolean createIncomplete : new boolean[] { true, false })
1395          for (Integer v1 : new Integer[] { 1, null })
1396      {
1397          final CompletableFuture<Integer> f = new CompletableFuture<>();
1398 <        final IncFunction r = new IncFunction(m);
1399 <        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 <        }
1398 >        final IncFunction[] rs = new IncFunction[4];
1399 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1400  
1401 <        checkCompletedNormally(g, inc(v1));
1401 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1402 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1403 >        checkIncomplete(h0);
1404 >        checkIncomplete(h1);
1405 >        assertTrue(f.complete(v1));
1406 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1407 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1408 >
1409 >        checkCompletedNormally(h0, inc(v1));
1410 >        checkCompletedNormally(h1, inc(v1));
1411 >        checkCompletedNormally(h2, inc(v1));
1412 >        checkCompletedNormally(h3, inc(v1));
1413          checkCompletedNormally(f, v1);
1414 <        r.assertInvoked();
1414 >        for (IncFunction r : rs) r.assertValue(inc(v1));
1415      }}
1416  
1417      /**
# Line 1180 | Line 1420 | public class CompletableFutureTest exten
1420       */
1421      public void testThenApply_exceptionalCompletion() {
1422          for (ExecutionMode m : ExecutionMode.values())
1183 –        for (boolean createIncomplete : new boolean[] { true, false })
1423      {
1424          final CFException ex = new CFException();
1425          final CompletableFuture<Integer> f = new CompletableFuture<>();
1426 <        final IncFunction r = new IncFunction(m);
1427 <        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 <        }
1426 >        final IncFunction[] rs = new IncFunction[4];
1427 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1428  
1429 <        checkCompletedWithWrappedCFException(g, ex);
1430 <        checkCompletedWithWrappedCFException(f, ex);
1431 <        r.assertNotInvoked();
1429 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1430 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1431 >        assertTrue(f.completeExceptionally(ex));
1432 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1433 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1434 >
1435 >        checkCompletedWithWrappedException(h0, ex);
1436 >        checkCompletedWithWrappedException(h1, ex);
1437 >        checkCompletedWithWrappedException(h2, ex);
1438 >        checkCompletedWithWrappedException(h3, ex);
1439 >        checkCompletedExceptionally(f, ex);
1440 >        for (IncFunction r : rs) r.assertNotInvoked();
1441      }}
1442  
1443      /**
# Line 1202 | Line 1445 | public class CompletableFutureTest exten
1445       */
1446      public void testThenApply_sourceCancelled() {
1447          for (ExecutionMode m : ExecutionMode.values())
1205 –        for (boolean createIncomplete : new boolean[] { true, false })
1448          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1449      {
1450          final CompletableFuture<Integer> f = new CompletableFuture<>();
1451 <        final IncFunction r = new IncFunction(m);
1452 <        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 <        }
1451 >        final IncFunction[] rs = new IncFunction[4];
1452 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1453  
1454 <        checkCompletedWithWrappedCancellationException(g);
1454 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1455 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1456 >        assertTrue(f.cancel(mayInterruptIfRunning));
1457 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1458 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1459 >
1460 >        checkCompletedWithWrappedCancellationException(h0);
1461 >        checkCompletedWithWrappedCancellationException(h1);
1462 >        checkCompletedWithWrappedCancellationException(h2);
1463 >        checkCompletedWithWrappedCancellationException(h3);
1464          checkCancelled(f);
1465 <        r.assertNotInvoked();
1465 >        for (IncFunction r : rs) r.assertNotInvoked();
1466      }}
1467  
1468      /**
# Line 1224 | Line 1470 | public class CompletableFutureTest exten
1470       */
1471      public void testThenApply_actionFailed() {
1472          for (ExecutionMode m : ExecutionMode.values())
1227 –        for (boolean createIncomplete : new boolean[] { true, false })
1473          for (Integer v1 : new Integer[] { 1, null })
1474      {
1475          final CompletableFuture<Integer> f = new CompletableFuture<>();
1476 <        final FailingFunction r = new FailingFunction(m);
1477 <        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 <        }
1476 >        final FailingFunction[] rs = new FailingFunction[4];
1477 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1478  
1479 <        checkCompletedWithWrappedCFException(g);
1479 >        final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1480 >        final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1481 >        assertTrue(f.complete(v1));
1482 >        final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1483 >        final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1484 >
1485 >        checkCompletedWithWrappedCFException(h0);
1486 >        checkCompletedWithWrappedCFException(h1);
1487 >        checkCompletedWithWrappedCFException(h2);
1488 >        checkCompletedWithWrappedCFException(h3);
1489          checkCompletedNormally(f, v1);
1490      }}
1491  
# Line 1245 | Line 1494 | public class CompletableFutureTest exten
1494       */
1495      public void testThenAccept_normalCompletion() {
1496          for (ExecutionMode m : ExecutionMode.values())
1248 –        for (boolean createIncomplete : new boolean[] { true, false })
1497          for (Integer v1 : new Integer[] { 1, null })
1498      {
1499          final CompletableFuture<Integer> f = new CompletableFuture<>();
1500 <        final NoopConsumer r = new NoopConsumer(m);
1501 <        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 <        }
1500 >        final NoopConsumer[] rs = new NoopConsumer[4];
1501 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1502  
1503 <        checkCompletedNormally(g, null);
1504 <        r.assertValue(v1);
1503 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1504 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1505 >        checkIncomplete(h0);
1506 >        checkIncomplete(h1);
1507 >        assertTrue(f.complete(v1));
1508 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1509 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1510 >
1511 >        checkCompletedNormally(h0, null);
1512 >        checkCompletedNormally(h1, null);
1513 >        checkCompletedNormally(h2, null);
1514 >        checkCompletedNormally(h3, null);
1515          checkCompletedNormally(f, v1);
1516 +        for (NoopConsumer r : rs) r.assertValue(v1);
1517      }}
1518  
1519      /**
# Line 1268 | Line 1522 | public class CompletableFutureTest exten
1522       */
1523      public void testThenAccept_exceptionalCompletion() {
1524          for (ExecutionMode m : ExecutionMode.values())
1271 –        for (boolean createIncomplete : new boolean[] { true, false })
1525      {
1526          final CFException ex = new CFException();
1527          final CompletableFuture<Integer> f = new CompletableFuture<>();
1528 <        final NoopConsumer r = new NoopConsumer(m);
1529 <        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 <        }
1528 >        final NoopConsumer[] rs = new NoopConsumer[4];
1529 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1530  
1531 <        checkCompletedWithWrappedCFException(g, ex);
1532 <        checkCompletedWithWrappedCFException(f, ex);
1533 <        r.assertNotInvoked();
1531 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1532 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1533 >        assertTrue(f.completeExceptionally(ex));
1534 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1535 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1536 >
1537 >        checkCompletedWithWrappedException(h0, ex);
1538 >        checkCompletedWithWrappedException(h1, ex);
1539 >        checkCompletedWithWrappedException(h2, ex);
1540 >        checkCompletedWithWrappedException(h3, ex);
1541 >        checkCompletedExceptionally(f, ex);
1542 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1543      }}
1544  
1545      /**
# Line 1290 | Line 1547 | public class CompletableFutureTest exten
1547       */
1548      public void testThenAccept_sourceCancelled() {
1549          for (ExecutionMode m : ExecutionMode.values())
1293 –        for (boolean createIncomplete : new boolean[] { true, false })
1550          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1551      {
1552          final CompletableFuture<Integer> f = new CompletableFuture<>();
1553 <        final NoopConsumer r = new NoopConsumer(m);
1554 <        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 <        }
1553 >        final NoopConsumer[] rs = new NoopConsumer[4];
1554 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1555  
1556 <        checkCompletedWithWrappedCancellationException(g);
1556 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1557 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1558 >        assertTrue(f.cancel(mayInterruptIfRunning));
1559 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1560 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1561 >
1562 >        checkCompletedWithWrappedCancellationException(h0);
1563 >        checkCompletedWithWrappedCancellationException(h1);
1564 >        checkCompletedWithWrappedCancellationException(h2);
1565 >        checkCompletedWithWrappedCancellationException(h3);
1566          checkCancelled(f);
1567 <        r.assertNotInvoked();
1567 >        for (NoopConsumer r : rs) r.assertNotInvoked();
1568      }}
1569  
1570      /**
# Line 1312 | Line 1572 | public class CompletableFutureTest exten
1572       */
1573      public void testThenAccept_actionFailed() {
1574          for (ExecutionMode m : ExecutionMode.values())
1315 –        for (boolean createIncomplete : new boolean[] { true, false })
1575          for (Integer v1 : new Integer[] { 1, null })
1576      {
1577          final CompletableFuture<Integer> f = new CompletableFuture<>();
1578 <        final FailingConsumer r = new FailingConsumer(m);
1579 <        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 <        }
1578 >        final FailingConsumer[] rs = new FailingConsumer[4];
1579 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
1580  
1581 <        checkCompletedWithWrappedCFException(g);
1581 >        final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1582 >        final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1583 >        assertTrue(f.complete(v1));
1584 >        final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1585 >        final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1586 >
1587 >        checkCompletedWithWrappedCFException(h0);
1588 >        checkCompletedWithWrappedCFException(h1);
1589 >        checkCompletedWithWrappedCFException(h2);
1590 >        checkCompletedWithWrappedCFException(h3);
1591          checkCompletedNormally(f, v1);
1592      }}
1593  
# Line 1334 | Line 1597 | public class CompletableFutureTest exten
1597       */
1598      public void testThenCombine_normalCompletion() {
1599          for (ExecutionMode m : ExecutionMode.values())
1337 –        for (boolean createIncomplete : new boolean[] { true, false })
1600          for (boolean fFirst : new boolean[] { true, false })
1601          for (Integer v1 : new Integer[] { 1, null })
1602          for (Integer v2 : new Integer[] { 2, null })
1603      {
1604          final CompletableFuture<Integer> f = new CompletableFuture<>();
1605          final CompletableFuture<Integer> g = new CompletableFuture<>();
1606 <        final SubtractFunction r = new SubtractFunction(m);
1606 >        final SubtractFunction[] rs = new SubtractFunction[6];
1607 >        for (int i = 0; i < rs.length; i++) rs[i] = new SubtractFunction(m);
1608  
1609 <        if (fFirst) f.complete(v1); else g.complete(v2);
1610 <        if (!createIncomplete)
1611 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1612 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1613 <        if (createIncomplete) {
1614 <            checkIncomplete(h);
1615 <            r.assertNotInvoked();
1616 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1617 <        }
1609 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1610 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1611 >        final Integer w1 =  fFirst ? v1 : v2;
1612 >        final Integer w2 = !fFirst ? v1 : v2;
1613 >
1614 >        final CompletableFuture<Integer> h0 = m.thenCombine(f, g, rs[0]);
1615 >        final CompletableFuture<Integer> h1 = m.thenCombine(fst, fst, rs[1]);
1616 >        assertTrue(fst.complete(w1));
1617 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, rs[2]);
1618 >        final CompletableFuture<Integer> h3 = m.thenCombine(fst, fst, rs[3]);
1619 >        checkIncomplete(h0); rs[0].assertNotInvoked();
1620 >        checkIncomplete(h2); rs[2].assertNotInvoked();
1621 >        checkCompletedNormally(h1, subtract(w1, w1));
1622 >        checkCompletedNormally(h3, subtract(w1, w1));
1623 >        rs[1].assertValue(subtract(w1, w1));
1624 >        rs[3].assertValue(subtract(w1, w1));
1625 >        assertTrue(snd.complete(w2));
1626 >        final CompletableFuture<Integer> h4 = m.thenCombine(f, g, rs[4]);
1627 >
1628 >        checkCompletedNormally(h0, subtract(v1, v2));
1629 >        checkCompletedNormally(h2, subtract(v1, v2));
1630 >        checkCompletedNormally(h4, subtract(v1, v2));
1631 >        rs[0].assertValue(subtract(v1, v2));
1632 >        rs[2].assertValue(subtract(v1, v2));
1633 >        rs[4].assertValue(subtract(v1, v2));
1634  
1356 –        checkCompletedNormally(h, subtract(v1, v2));
1635          checkCompletedNormally(f, v1);
1636          checkCompletedNormally(g, v2);
1359 –        r.assertInvoked();
1637      }}
1638  
1639      /**
1640       * thenCombine result completes exceptionally after exceptional
1641       * completion of either source
1642       */
1643 <    public void testThenCombine_exceptionalCompletion() {
1643 >    public void testThenCombine_exceptionalCompletion() throws Throwable {
1644          for (ExecutionMode m : ExecutionMode.values())
1368 –        for (boolean createIncomplete : new boolean[] { true, false })
1645          for (boolean fFirst : new boolean[] { true, false })
1646 +        for (boolean failFirst : new boolean[] { true, false })
1647          for (Integer v1 : new Integer[] { 1, null })
1648      {
1649          final CompletableFuture<Integer> f = new CompletableFuture<>();
1650          final CompletableFuture<Integer> g = new CompletableFuture<>();
1651          final CFException ex = new CFException();
1652 <        final SubtractFunction r = new SubtractFunction(m);
1653 <
1654 <        (fFirst ? f : g).complete(v1);
1655 <        if (!createIncomplete)
1656 <            (!fFirst ? f : g).completeExceptionally(ex);
1657 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1658 <        if (createIncomplete) {
1659 <            checkIncomplete(h);
1660 <            (!fFirst ? f : g).completeExceptionally(ex);
1661 <        }
1662 <
1663 <        checkCompletedWithWrappedCFException(h, ex);
1664 <        r.assertNotInvoked();
1665 <        checkCompletedNormally(fFirst ? f : g, v1);
1666 <        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1652 >        final SubtractFunction r1 = new SubtractFunction(m);
1653 >        final SubtractFunction r2 = new SubtractFunction(m);
1654 >        final SubtractFunction r3 = new SubtractFunction(m);
1655 >
1656 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1657 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1658 >        final Callable<Boolean> complete1 = failFirst ?
1659 >            () -> fst.completeExceptionally(ex) :
1660 >            () -> fst.complete(v1);
1661 >        final Callable<Boolean> complete2 = failFirst ?
1662 >            () -> snd.complete(v1) :
1663 >            () -> snd.completeExceptionally(ex);
1664 >
1665 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1666 >        assertTrue(complete1.call());
1667 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1668 >        checkIncomplete(h1);
1669 >        checkIncomplete(h2);
1670 >        assertTrue(complete2.call());
1671 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1672 >
1673 >        checkCompletedWithWrappedException(h1, ex);
1674 >        checkCompletedWithWrappedException(h2, ex);
1675 >        checkCompletedWithWrappedException(h3, ex);
1676 >        r1.assertNotInvoked();
1677 >        r2.assertNotInvoked();
1678 >        r3.assertNotInvoked();
1679 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1680 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1681      }}
1682  
1683      /**
1684       * thenCombine result completes exceptionally if either source cancelled
1685       */
1686 <    public void testThenCombine_sourceCancelled() {
1686 >    public void testThenCombine_sourceCancelled() throws Throwable {
1687          for (ExecutionMode m : ExecutionMode.values())
1688          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1398 –        for (boolean createIncomplete : new boolean[] { true, false })
1689          for (boolean fFirst : new boolean[] { true, false })
1690 +        for (boolean failFirst : new boolean[] { true, false })
1691          for (Integer v1 : new Integer[] { 1, null })
1692      {
1693          final CompletableFuture<Integer> f = new CompletableFuture<>();
1694          final CompletableFuture<Integer> g = new CompletableFuture<>();
1695 <        final SubtractFunction r = new SubtractFunction(m);
1695 >        final SubtractFunction r1 = new SubtractFunction(m);
1696 >        final SubtractFunction r2 = new SubtractFunction(m);
1697 >        final SubtractFunction r3 = new SubtractFunction(m);
1698  
1699 <        (fFirst ? f : g).complete(v1);
1700 <        if (!createIncomplete)
1701 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1702 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1703 <        if (createIncomplete) {
1704 <            checkIncomplete(h);
1705 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1706 <        }
1699 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1700 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1701 >        final Callable<Boolean> complete1 = failFirst ?
1702 >            () -> fst.cancel(mayInterruptIfRunning) :
1703 >            () -> fst.complete(v1);
1704 >        final Callable<Boolean> complete2 = failFirst ?
1705 >            () -> snd.complete(v1) :
1706 >            () -> snd.cancel(mayInterruptIfRunning);
1707  
1708 <        checkCompletedWithWrappedCancellationException(h);
1709 <        checkCancelled(!fFirst ? f : g);
1710 <        r.assertNotInvoked();
1711 <        checkCompletedNormally(fFirst ? f : g, v1);
1708 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1709 >        assertTrue(complete1.call());
1710 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1711 >        checkIncomplete(h1);
1712 >        checkIncomplete(h2);
1713 >        assertTrue(complete2.call());
1714 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1715 >
1716 >        checkCompletedWithWrappedCancellationException(h1);
1717 >        checkCompletedWithWrappedCancellationException(h2);
1718 >        checkCompletedWithWrappedCancellationException(h3);
1719 >        r1.assertNotInvoked();
1720 >        r2.assertNotInvoked();
1721 >        r3.assertNotInvoked();
1722 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1723 >        checkCancelled(failFirst ? fst : snd);
1724      }}
1725  
1726      /**
# Line 1429 | Line 1734 | public class CompletableFutureTest exten
1734      {
1735          final CompletableFuture<Integer> f = new CompletableFuture<>();
1736          final CompletableFuture<Integer> g = new CompletableFuture<>();
1737 <        final FailingBiFunction r = new FailingBiFunction(m);
1738 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1739 <
1740 <        if (fFirst) {
1741 <            f.complete(v1);
1742 <            g.complete(v2);
1743 <        } else {
1744 <            g.complete(v2);
1745 <            f.complete(v1);
1746 <        }
1737 >        final FailingBiFunction r1 = new FailingBiFunction(m);
1738 >        final FailingBiFunction r2 = new FailingBiFunction(m);
1739 >        final FailingBiFunction r3 = new FailingBiFunction(m);
1740 >
1741 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1742 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1743 >        final Integer w1 =  fFirst ? v1 : v2;
1744 >        final Integer w2 = !fFirst ? v1 : v2;
1745 >
1746 >        final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1747 >        assertTrue(fst.complete(w1));
1748 >        final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1749 >        assertTrue(snd.complete(w2));
1750 >        final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1751  
1752 <        checkCompletedWithWrappedCFException(h);
1752 >        checkCompletedWithWrappedCFException(h1);
1753 >        checkCompletedWithWrappedCFException(h2);
1754 >        checkCompletedWithWrappedCFException(h3);
1755 >        r1.assertInvoked();
1756 >        r2.assertInvoked();
1757 >        r3.assertInvoked();
1758          checkCompletedNormally(f, v1);
1759          checkCompletedNormally(g, v2);
1760      }}
# Line 1451 | Line 1765 | public class CompletableFutureTest exten
1765       */
1766      public void testThenAcceptBoth_normalCompletion() {
1767          for (ExecutionMode m : ExecutionMode.values())
1454 –        for (boolean createIncomplete : new boolean[] { true, false })
1768          for (boolean fFirst : new boolean[] { true, false })
1769          for (Integer v1 : new Integer[] { 1, null })
1770          for (Integer v2 : new Integer[] { 2, null })
1771      {
1772          final CompletableFuture<Integer> f = new CompletableFuture<>();
1773          final CompletableFuture<Integer> g = new CompletableFuture<>();
1774 <        final SubtractAction r = new SubtractAction(m);
1775 <
1776 <        if (fFirst) f.complete(v1); else g.complete(v2);
1777 <        if (!createIncomplete)
1778 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1779 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1780 <        if (createIncomplete) {
1781 <            checkIncomplete(h);
1782 <            r.assertNotInvoked();
1783 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1784 <        }
1774 >        final SubtractAction r1 = new SubtractAction(m);
1775 >        final SubtractAction r2 = new SubtractAction(m);
1776 >        final SubtractAction r3 = new SubtractAction(m);
1777 >
1778 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1779 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1780 >        final Integer w1 =  fFirst ? v1 : v2;
1781 >        final Integer w2 = !fFirst ? v1 : v2;
1782 >
1783 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1784 >        assertTrue(fst.complete(w1));
1785 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1786 >        checkIncomplete(h1);
1787 >        checkIncomplete(h2);
1788 >        r1.assertNotInvoked();
1789 >        r2.assertNotInvoked();
1790 >        assertTrue(snd.complete(w2));
1791 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1792  
1793 <        checkCompletedNormally(h, null);
1794 <        r.assertValue(subtract(v1, v2));
1793 >        checkCompletedNormally(h1, null);
1794 >        checkCompletedNormally(h2, null);
1795 >        checkCompletedNormally(h3, null);
1796 >        r1.assertValue(subtract(v1, v2));
1797 >        r2.assertValue(subtract(v1, v2));
1798 >        r3.assertValue(subtract(v1, v2));
1799          checkCompletedNormally(f, v1);
1800          checkCompletedNormally(g, v2);
1801      }}
# Line 1480 | Line 1804 | public class CompletableFutureTest exten
1804       * thenAcceptBoth result completes exceptionally after exceptional
1805       * completion of either source
1806       */
1807 <    public void testThenAcceptBoth_exceptionalCompletion() {
1807 >    public void testThenAcceptBoth_exceptionalCompletion() throws Throwable {
1808          for (ExecutionMode m : ExecutionMode.values())
1485 –        for (boolean createIncomplete : new boolean[] { true, false })
1809          for (boolean fFirst : new boolean[] { true, false })
1810 +        for (boolean failFirst : new boolean[] { true, false })
1811          for (Integer v1 : new Integer[] { 1, null })
1812      {
1813          final CompletableFuture<Integer> f = new CompletableFuture<>();
1814          final CompletableFuture<Integer> g = new CompletableFuture<>();
1815          final CFException ex = new CFException();
1816 <        final SubtractAction r = new SubtractAction(m);
1817 <
1818 <        (fFirst ? f : g).complete(v1);
1819 <        if (!createIncomplete)
1820 <            (!fFirst ? f : g).completeExceptionally(ex);
1821 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1822 <        if (createIncomplete) {
1823 <            checkIncomplete(h);
1824 <            (!fFirst ? f : g).completeExceptionally(ex);
1825 <        }
1826 <
1827 <        checkCompletedWithWrappedCFException(h, ex);
1828 <        r.assertNotInvoked();
1829 <        checkCompletedNormally(fFirst ? f : g, v1);
1830 <        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1816 >        final SubtractAction r1 = new SubtractAction(m);
1817 >        final SubtractAction r2 = new SubtractAction(m);
1818 >        final SubtractAction r3 = new SubtractAction(m);
1819 >
1820 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1821 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1822 >        final Callable<Boolean> complete1 = failFirst ?
1823 >            () -> fst.completeExceptionally(ex) :
1824 >            () -> fst.complete(v1);
1825 >        final Callable<Boolean> complete2 = failFirst ?
1826 >            () -> snd.complete(v1) :
1827 >            () -> snd.completeExceptionally(ex);
1828 >
1829 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1830 >        assertTrue(complete1.call());
1831 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1832 >        checkIncomplete(h1);
1833 >        checkIncomplete(h2);
1834 >        assertTrue(complete2.call());
1835 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1836 >
1837 >        checkCompletedWithWrappedException(h1, ex);
1838 >        checkCompletedWithWrappedException(h2, ex);
1839 >        checkCompletedWithWrappedException(h3, ex);
1840 >        r1.assertNotInvoked();
1841 >        r2.assertNotInvoked();
1842 >        r3.assertNotInvoked();
1843 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1844 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
1845      }}
1846  
1847      /**
1848       * thenAcceptBoth result completes exceptionally if either source cancelled
1849       */
1850 <    public void testThenAcceptBoth_sourceCancelled() {
1850 >    public void testThenAcceptBoth_sourceCancelled() throws Throwable {
1851          for (ExecutionMode m : ExecutionMode.values())
1852          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1515 –        for (boolean createIncomplete : new boolean[] { true, false })
1853          for (boolean fFirst : new boolean[] { true, false })
1854 +        for (boolean failFirst : new boolean[] { true, false })
1855          for (Integer v1 : new Integer[] { 1, null })
1856      {
1857          final CompletableFuture<Integer> f = new CompletableFuture<>();
1858          final CompletableFuture<Integer> g = new CompletableFuture<>();
1859 <        final SubtractAction r = new SubtractAction(m);
1859 >        final SubtractAction r1 = new SubtractAction(m);
1860 >        final SubtractAction r2 = new SubtractAction(m);
1861 >        final SubtractAction r3 = new SubtractAction(m);
1862  
1863 <        (fFirst ? f : g).complete(v1);
1864 <        if (!createIncomplete)
1865 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1866 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1867 <        if (createIncomplete) {
1868 <            checkIncomplete(h);
1869 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1870 <        }
1863 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1864 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1865 >        final Callable<Boolean> complete1 = failFirst ?
1866 >            () -> fst.cancel(mayInterruptIfRunning) :
1867 >            () -> fst.complete(v1);
1868 >        final Callable<Boolean> complete2 = failFirst ?
1869 >            () -> snd.complete(v1) :
1870 >            () -> snd.cancel(mayInterruptIfRunning);
1871  
1872 <        checkCompletedWithWrappedCancellationException(h);
1873 <        checkCancelled(!fFirst ? f : g);
1874 <        r.assertNotInvoked();
1875 <        checkCompletedNormally(fFirst ? f : g, v1);
1872 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1873 >        assertTrue(complete1.call());
1874 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1875 >        checkIncomplete(h1);
1876 >        checkIncomplete(h2);
1877 >        assertTrue(complete2.call());
1878 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1879 >
1880 >        checkCompletedWithWrappedCancellationException(h1);
1881 >        checkCompletedWithWrappedCancellationException(h2);
1882 >        checkCompletedWithWrappedCancellationException(h3);
1883 >        r1.assertNotInvoked();
1884 >        r2.assertNotInvoked();
1885 >        r3.assertNotInvoked();
1886 >        checkCompletedNormally(failFirst ? snd : fst, v1);
1887 >        checkCancelled(failFirst ? fst : snd);
1888      }}
1889  
1890      /**
# Line 1546 | Line 1898 | public class CompletableFutureTest exten
1898      {
1899          final CompletableFuture<Integer> f = new CompletableFuture<>();
1900          final CompletableFuture<Integer> g = new CompletableFuture<>();
1901 <        final FailingBiConsumer r = new FailingBiConsumer(m);
1902 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1903 <
1904 <        if (fFirst) {
1905 <            f.complete(v1);
1906 <            g.complete(v2);
1907 <        } else {
1908 <            g.complete(v2);
1909 <            f.complete(v1);
1910 <        }
1901 >        final FailingBiConsumer r1 = new FailingBiConsumer(m);
1902 >        final FailingBiConsumer r2 = new FailingBiConsumer(m);
1903 >        final FailingBiConsumer r3 = new FailingBiConsumer(m);
1904 >
1905 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1906 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1907 >        final Integer w1 =  fFirst ? v1 : v2;
1908 >        final Integer w2 = !fFirst ? v1 : v2;
1909 >
1910 >        final CompletableFuture<Void> h1 = m.thenAcceptBoth(f, g, r1);
1911 >        assertTrue(fst.complete(w1));
1912 >        final CompletableFuture<Void> h2 = m.thenAcceptBoth(f, g, r2);
1913 >        assertTrue(snd.complete(w2));
1914 >        final CompletableFuture<Void> h3 = m.thenAcceptBoth(f, g, r3);
1915  
1916 <        checkCompletedWithWrappedCFException(h);
1916 >        checkCompletedWithWrappedCFException(h1);
1917 >        checkCompletedWithWrappedCFException(h2);
1918 >        checkCompletedWithWrappedCFException(h3);
1919 >        r1.assertInvoked();
1920 >        r2.assertInvoked();
1921 >        r3.assertInvoked();
1922          checkCompletedNormally(f, v1);
1923          checkCompletedNormally(g, v2);
1924      }}
# Line 1568 | Line 1929 | public class CompletableFutureTest exten
1929       */
1930      public void testRunAfterBoth_normalCompletion() {
1931          for (ExecutionMode m : ExecutionMode.values())
1571 –        for (boolean createIncomplete : new boolean[] { true, false })
1932          for (boolean fFirst : new boolean[] { true, false })
1933          for (Integer v1 : new Integer[] { 1, null })
1934          for (Integer v2 : new Integer[] { 2, null })
1935      {
1936          final CompletableFuture<Integer> f = new CompletableFuture<>();
1937          final CompletableFuture<Integer> g = new CompletableFuture<>();
1938 <        final Noop r = new Noop(m);
1939 <
1940 <        if (fFirst) f.complete(v1); else g.complete(v2);
1941 <        if (!createIncomplete)
1942 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1943 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1944 <        if (createIncomplete) {
1945 <            checkIncomplete(h);
1946 <            r.assertNotInvoked();
1947 <            if (!fFirst) f.complete(v1); else g.complete(v2);
1948 <        }
1938 >        final Noop r1 = new Noop(m);
1939 >        final Noop r2 = new Noop(m);
1940 >        final Noop r3 = new Noop(m);
1941 >
1942 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1943 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1944 >        final Integer w1 =  fFirst ? v1 : v2;
1945 >        final Integer w2 = !fFirst ? v1 : v2;
1946 >
1947 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1948 >        assertTrue(fst.complete(w1));
1949 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1950 >        checkIncomplete(h1);
1951 >        checkIncomplete(h2);
1952 >        r1.assertNotInvoked();
1953 >        r2.assertNotInvoked();
1954 >        assertTrue(snd.complete(w2));
1955 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
1956  
1957 <        checkCompletedNormally(h, null);
1958 <        r.assertInvoked();
1957 >        checkCompletedNormally(h1, null);
1958 >        checkCompletedNormally(h2, null);
1959 >        checkCompletedNormally(h3, null);
1960 >        r1.assertInvoked();
1961 >        r2.assertInvoked();
1962 >        r3.assertInvoked();
1963          checkCompletedNormally(f, v1);
1964          checkCompletedNormally(g, v2);
1965      }}
# Line 1597 | Line 1968 | public class CompletableFutureTest exten
1968       * runAfterBoth result completes exceptionally after exceptional
1969       * completion of either source
1970       */
1971 <    public void testRunAfterBoth_exceptionalCompletion() {
1971 >    public void testRunAfterBoth_exceptionalCompletion() throws Throwable {
1972          for (ExecutionMode m : ExecutionMode.values())
1602 –        for (boolean createIncomplete : new boolean[] { true, false })
1973          for (boolean fFirst : new boolean[] { true, false })
1974 +        for (boolean failFirst : new boolean[] { true, false })
1975          for (Integer v1 : new Integer[] { 1, null })
1976      {
1977          final CompletableFuture<Integer> f = new CompletableFuture<>();
1978          final CompletableFuture<Integer> g = new CompletableFuture<>();
1979          final CFException ex = new CFException();
1980 <        final Noop r = new Noop(m);
1981 <
1982 <        (fFirst ? f : g).complete(v1);
1983 <        if (!createIncomplete)
1984 <            (!fFirst ? f : g).completeExceptionally(ex);
1985 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1986 <        if (createIncomplete) {
1987 <            checkIncomplete(h);
1988 <            (!fFirst ? f : g).completeExceptionally(ex);
1989 <        }
1990 <
1991 <        checkCompletedWithWrappedCFException(h, ex);
1992 <        r.assertNotInvoked();
1993 <        checkCompletedNormally(fFirst ? f : g, v1);
1994 <        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1980 >        final Noop r1 = new Noop(m);
1981 >        final Noop r2 = new Noop(m);
1982 >        final Noop r3 = new Noop(m);
1983 >
1984 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
1985 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
1986 >        final Callable<Boolean> complete1 = failFirst ?
1987 >            () -> fst.completeExceptionally(ex) :
1988 >            () -> fst.complete(v1);
1989 >        final Callable<Boolean> complete2 = failFirst ?
1990 >            () -> snd.complete(v1) :
1991 >            () -> snd.completeExceptionally(ex);
1992 >
1993 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1994 >        assertTrue(complete1.call());
1995 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1996 >        checkIncomplete(h1);
1997 >        checkIncomplete(h2);
1998 >        assertTrue(complete2.call());
1999 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2000 >
2001 >        checkCompletedWithWrappedException(h1, ex);
2002 >        checkCompletedWithWrappedException(h2, ex);
2003 >        checkCompletedWithWrappedException(h3, ex);
2004 >        r1.assertNotInvoked();
2005 >        r2.assertNotInvoked();
2006 >        r3.assertNotInvoked();
2007 >        checkCompletedNormally(failFirst ? snd : fst, v1);
2008 >        checkCompletedExceptionally(failFirst ? fst : snd, ex);
2009      }}
2010  
2011      /**
2012       * runAfterBoth result completes exceptionally if either source cancelled
2013       */
2014 <    public void testRunAfterBoth_sourceCancelled() {
2014 >    public void testRunAfterBoth_sourceCancelled() throws Throwable {
2015          for (ExecutionMode m : ExecutionMode.values())
2016          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1632 –        for (boolean createIncomplete : new boolean[] { true, false })
2017          for (boolean fFirst : new boolean[] { true, false })
2018 +        for (boolean failFirst : new boolean[] { true, false })
2019          for (Integer v1 : new Integer[] { 1, null })
2020      {
2021          final CompletableFuture<Integer> f = new CompletableFuture<>();
2022          final CompletableFuture<Integer> g = new CompletableFuture<>();
2023 <        final Noop r = new Noop(m);
2023 >        final Noop r1 = new Noop(m);
2024 >        final Noop r2 = new Noop(m);
2025 >        final Noop r3 = new Noop(m);
2026  
2027 +        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2028 +        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2029 +        final Callable<Boolean> complete1 = failFirst ?
2030 +            () -> fst.cancel(mayInterruptIfRunning) :
2031 +            () -> fst.complete(v1);
2032 +        final Callable<Boolean> complete2 = failFirst ?
2033 +            () -> snd.complete(v1) :
2034 +            () -> snd.cancel(mayInterruptIfRunning);
2035  
2036 <        (fFirst ? f : g).complete(v1);
2037 <        if (!createIncomplete)
2038 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
2039 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
2040 <        if (createIncomplete) {
2041 <            checkIncomplete(h);
2042 <            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1648 <        }
2036 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2037 >        assertTrue(complete1.call());
2038 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2039 >        checkIncomplete(h1);
2040 >        checkIncomplete(h2);
2041 >        assertTrue(complete2.call());
2042 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2043  
2044 <        checkCompletedWithWrappedCancellationException(h);
2045 <        checkCancelled(!fFirst ? f : g);
2046 <        r.assertNotInvoked();
2047 <        checkCompletedNormally(fFirst ? f : g, v1);
2044 >        checkCompletedWithWrappedCancellationException(h1);
2045 >        checkCompletedWithWrappedCancellationException(h2);
2046 >        checkCompletedWithWrappedCancellationException(h3);
2047 >        r1.assertNotInvoked();
2048 >        r2.assertNotInvoked();
2049 >        r3.assertNotInvoked();
2050 >        checkCompletedNormally(failFirst ? snd : fst, v1);
2051 >        checkCancelled(failFirst ? fst : snd);
2052      }}
2053  
2054      /**
# Line 1666 | Line 2064 | public class CompletableFutureTest exten
2064          final CompletableFuture<Integer> g = new CompletableFuture<>();
2065          final FailingRunnable r1 = new FailingRunnable(m);
2066          final FailingRunnable r2 = new FailingRunnable(m);
2067 +        final FailingRunnable r3 = new FailingRunnable(m);
2068  
2069 <        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2070 <        if (fFirst) {
2071 <            f.complete(v1);
2072 <            g.complete(v2);
2073 <        } else {
2074 <            g.complete(v2);
2075 <            f.complete(v1);
2076 <        }
2077 <        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2069 >        final CompletableFuture<Integer> fst =  fFirst ? f : g;
2070 >        final CompletableFuture<Integer> snd = !fFirst ? f : g;
2071 >        final Integer w1 =  fFirst ? v1 : v2;
2072 >        final Integer w2 = !fFirst ? v1 : v2;
2073 >
2074 >        final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
2075 >        assertTrue(fst.complete(w1));
2076 >        final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
2077 >        assertTrue(snd.complete(w2));
2078 >        final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);
2079  
2080          checkCompletedWithWrappedCFException(h1);
2081          checkCompletedWithWrappedCFException(h2);
2082 +        checkCompletedWithWrappedCFException(h3);
2083 +        r1.assertInvoked();
2084 +        r2.assertInvoked();
2085 +        r3.assertInvoked();
2086          checkCompletedNormally(f, v1);
2087          checkCompletedNormally(g, v2);
2088      }}
# Line 1752 | Line 2156 | public class CompletableFutureTest exten
2156          rs[0].assertNotInvoked();
2157          rs[1].assertNotInvoked();
2158          f.completeExceptionally(ex);
2159 <        checkCompletedWithWrappedCFException(h0, ex);
2160 <        checkCompletedWithWrappedCFException(h1, ex);
2159 >        checkCompletedWithWrappedException(h0, ex);
2160 >        checkCompletedWithWrappedException(h1, ex);
2161          final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2162          final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2163 <        checkCompletedWithWrappedCFException(h2, ex);
2164 <        checkCompletedWithWrappedCFException(h3, ex);
2163 >        checkCompletedWithWrappedException(h2, ex);
2164 >        checkCompletedWithWrappedException(h3, ex);
2165          g.complete(v1);
2166  
2167          // unspecified behavior - both source completions available
# Line 1767 | Line 2171 | public class CompletableFutureTest exten
2171              assertEquals(inc(v1), h4.join());
2172              rs[4].assertValue(inc(v1));
2173          } catch (CompletionException ok) {
2174 <            checkCompletedWithWrappedCFException(h4, ex);
2174 >            checkCompletedWithWrappedException(h4, ex);
2175              rs[4].assertNotInvoked();
2176          }
2177          try {
2178              assertEquals(inc(v1), h5.join());
2179              rs[5].assertValue(inc(v1));
2180          } catch (CompletionException ok) {
2181 <            checkCompletedWithWrappedCFException(h5, ex);
2181 >            checkCompletedWithWrappedException(h5, ex);
2182              rs[5].assertNotInvoked();
2183          }
2184  
2185 <        checkCompletedWithWrappedCFException(f, ex);
2185 >        checkCompletedExceptionally(f, ex);
2186          checkCompletedNormally(g, v1);
2187 <        checkCompletedWithWrappedCFException(h0, ex);
2188 <        checkCompletedWithWrappedCFException(h1, ex);
2189 <        checkCompletedWithWrappedCFException(h2, ex);
2190 <        checkCompletedWithWrappedCFException(h3, ex);
2191 <        checkCompletedWithWrappedCFException(h4, ex);
2187 >        checkCompletedWithWrappedException(h0, ex);
2188 >        checkCompletedWithWrappedException(h1, ex);
2189 >        checkCompletedWithWrappedException(h2, ex);
2190 >        checkCompletedWithWrappedException(h3, ex);
2191 >        checkCompletedWithWrappedException(h4, ex);
2192          for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2193      }}
2194  
# Line 1801 | Line 2205 | public class CompletableFutureTest exten
2205  
2206          final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2207          final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2208 <        if (fFirst) {
2209 <            f.complete(v1);
1806 <            g.completeExceptionally(ex);
1807 <        } else {
1808 <            g.completeExceptionally(ex);
1809 <            f.complete(v1);
1810 <        }
2208 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2209 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2210          final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2211          final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2212  
# Line 1816 | Line 2215 | public class CompletableFutureTest exten
2215              assertEquals(inc(v1), h0.join());
2216              rs[0].assertValue(inc(v1));
2217          } catch (CompletionException ok) {
2218 <            checkCompletedWithWrappedCFException(h0, ex);
2218 >            checkCompletedWithWrappedException(h0, ex);
2219              rs[0].assertNotInvoked();
2220          }
2221          try {
2222              assertEquals(inc(v1), h1.join());
2223              rs[1].assertValue(inc(v1));
2224          } catch (CompletionException ok) {
2225 <            checkCompletedWithWrappedCFException(h1, ex);
2225 >            checkCompletedWithWrappedException(h1, ex);
2226              rs[1].assertNotInvoked();
2227          }
2228          try {
2229              assertEquals(inc(v1), h2.join());
2230              rs[2].assertValue(inc(v1));
2231          } catch (CompletionException ok) {
2232 <            checkCompletedWithWrappedCFException(h2, ex);
2232 >            checkCompletedWithWrappedException(h2, ex);
2233              rs[2].assertNotInvoked();
2234          }
2235          try {
2236              assertEquals(inc(v1), h3.join());
2237              rs[3].assertValue(inc(v1));
2238          } catch (CompletionException ok) {
2239 <            checkCompletedWithWrappedCFException(h3, ex);
2239 >            checkCompletedWithWrappedException(h3, ex);
2240              rs[3].assertNotInvoked();
2241          }
2242  
2243          checkCompletedNormally(f, v1);
2244 <        checkCompletedWithWrappedCFException(g, ex);
2244 >        checkCompletedExceptionally(g, ex);
2245      }}
2246  
2247      /**
# Line 1913 | Line 2312 | public class CompletableFutureTest exten
2312  
2313          final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
2314          final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
2315 <        if (fFirst) {
2316 <            f.complete(v1);
1918 <            g.cancel(mayInterruptIfRunning);
1919 <        } else {
1920 <            g.cancel(mayInterruptIfRunning);
1921 <            f.complete(v1);
1922 <        }
2315 >        assertTrue(fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2316 >        assertTrue(!fFirst ? f.complete(v1) : g.cancel(mayInterruptIfRunning));
2317          final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
2318          final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
2319  
# Line 2071 | Line 2465 | public class CompletableFutureTest exten
2465          rs[0].assertNotInvoked();
2466          rs[1].assertNotInvoked();
2467          f.completeExceptionally(ex);
2468 <        checkCompletedWithWrappedCFException(h0, ex);
2469 <        checkCompletedWithWrappedCFException(h1, ex);
2468 >        checkCompletedWithWrappedException(h0, ex);
2469 >        checkCompletedWithWrappedException(h1, ex);
2470          final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2471          final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2472 <        checkCompletedWithWrappedCFException(h2, ex);
2473 <        checkCompletedWithWrappedCFException(h3, ex);
2472 >        checkCompletedWithWrappedException(h2, ex);
2473 >        checkCompletedWithWrappedException(h3, ex);
2474  
2475          g.complete(v1);
2476  
# Line 2087 | Line 2481 | public class CompletableFutureTest exten
2481              assertNull(h4.join());
2482              rs[4].assertValue(v1);
2483          } catch (CompletionException ok) {
2484 <            checkCompletedWithWrappedCFException(h4, ex);
2484 >            checkCompletedWithWrappedException(h4, ex);
2485              rs[4].assertNotInvoked();
2486          }
2487          try {
2488              assertNull(h5.join());
2489              rs[5].assertValue(v1);
2490          } catch (CompletionException ok) {
2491 <            checkCompletedWithWrappedCFException(h5, ex);
2491 >            checkCompletedWithWrappedException(h5, ex);
2492              rs[5].assertNotInvoked();
2493          }
2494  
2495 <        checkCompletedWithWrappedCFException(f, ex);
2495 >        checkCompletedExceptionally(f, ex);
2496          checkCompletedNormally(g, v1);
2497 <        checkCompletedWithWrappedCFException(h0, ex);
2498 <        checkCompletedWithWrappedCFException(h1, ex);
2499 <        checkCompletedWithWrappedCFException(h2, ex);
2500 <        checkCompletedWithWrappedCFException(h3, ex);
2501 <        checkCompletedWithWrappedCFException(h4, ex);
2497 >        checkCompletedWithWrappedException(h0, ex);
2498 >        checkCompletedWithWrappedException(h1, ex);
2499 >        checkCompletedWithWrappedException(h2, ex);
2500 >        checkCompletedWithWrappedException(h3, ex);
2501 >        checkCompletedWithWrappedException(h4, ex);
2502          for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2503      }}
2504  
# Line 2121 | Line 2515 | public class CompletableFutureTest exten
2515  
2516          final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2517          final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2518 <        if (fFirst) {
2519 <            f.complete(v1);
2126 <            g.completeExceptionally(ex);
2127 <        } else {
2128 <            g.completeExceptionally(ex);
2129 <            f.complete(v1);
2130 <        }
2518 >        assertTrue(fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2519 >        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2520          final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2521          final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2522  
# Line 2136 | Line 2525 | public class CompletableFutureTest exten
2525              assertEquals(null, h0.join());
2526              rs[0].assertValue(v1);
2527          } catch (CompletionException ok) {
2528 <            checkCompletedWithWrappedCFException(h0, ex);
2528 >            checkCompletedWithWrappedException(h0, ex);
2529              rs[0].assertNotInvoked();
2530          }
2531          try {
2532              assertEquals(null, h1.join());
2533              rs[1].assertValue(v1);
2534          } catch (CompletionException ok) {
2535 <            checkCompletedWithWrappedCFException(h1, ex);
2535 >            checkCompletedWithWrappedException(h1, ex);
2536              rs[1].assertNotInvoked();
2537          }
2538          try {
2539              assertEquals(null, h2.join());
2540              rs[2].assertValue(v1);
2541          } catch (CompletionException ok) {
2542 <            checkCompletedWithWrappedCFException(h2, ex);
2542 >            checkCompletedWithWrappedException(h2, ex);
2543              rs[2].assertNotInvoked();
2544          }
2545          try {
2546              assertEquals(null, h3.join());
2547              rs[3].assertValue(v1);
2548          } catch (CompletionException ok) {
2549 <            checkCompletedWithWrappedCFException(h3, ex);
2549 >            checkCompletedWithWrappedException(h3, ex);
2550              rs[3].assertNotInvoked();
2551          }
2552  
2553          checkCompletedNormally(f, v1);
2554 <        checkCompletedWithWrappedCFException(g, ex);
2554 >        checkCompletedExceptionally(g, ex);
2555      }}
2556  
2557      /**
# Line 2330 | Line 2719 | public class CompletableFutureTest exten
2719          checkIncomplete(h1);
2720          rs[0].assertNotInvoked();
2721          rs[1].assertNotInvoked();
2722 <        f.completeExceptionally(ex);
2723 <        checkCompletedWithWrappedCFException(h0, ex);
2724 <        checkCompletedWithWrappedCFException(h1, ex);
2722 >        assertTrue(f.completeExceptionally(ex));
2723 >        checkCompletedWithWrappedException(h0, ex);
2724 >        checkCompletedWithWrappedException(h1, ex);
2725          final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2726          final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2727 <        checkCompletedWithWrappedCFException(h2, ex);
2728 <        checkCompletedWithWrappedCFException(h3, ex);
2727 >        checkCompletedWithWrappedException(h2, ex);
2728 >        checkCompletedWithWrappedException(h3, ex);
2729  
2730 <        g.complete(v1);
2730 >        assertTrue(g.complete(v1));
2731  
2732          // unspecified behavior - both source completions available
2733          final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
# Line 2347 | Line 2736 | public class CompletableFutureTest exten
2736              assertNull(h4.join());
2737              rs[4].assertInvoked();
2738          } catch (CompletionException ok) {
2739 <            checkCompletedWithWrappedCFException(h4, ex);
2739 >            checkCompletedWithWrappedException(h4, ex);
2740              rs[4].assertNotInvoked();
2741          }
2742          try {
2743              assertNull(h5.join());
2744              rs[5].assertInvoked();
2745          } catch (CompletionException ok) {
2746 <            checkCompletedWithWrappedCFException(h5, ex);
2746 >            checkCompletedWithWrappedException(h5, ex);
2747              rs[5].assertNotInvoked();
2748          }
2749  
2750 <        checkCompletedWithWrappedCFException(f, ex);
2750 >        checkCompletedExceptionally(f, ex);
2751          checkCompletedNormally(g, v1);
2752 <        checkCompletedWithWrappedCFException(h0, ex);
2753 <        checkCompletedWithWrappedCFException(h1, ex);
2754 <        checkCompletedWithWrappedCFException(h2, ex);
2755 <        checkCompletedWithWrappedCFException(h3, ex);
2756 <        checkCompletedWithWrappedCFException(h4, ex);
2752 >        checkCompletedWithWrappedException(h0, ex);
2753 >        checkCompletedWithWrappedException(h1, ex);
2754 >        checkCompletedWithWrappedException(h2, ex);
2755 >        checkCompletedWithWrappedException(h3, ex);
2756 >        checkCompletedWithWrappedException(h4, ex);
2757          for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2758      }}
2759  
2760 +    public void testRunAfterEither_exceptionalCompletion2() {
2761 +        for (ExecutionMode m : ExecutionMode.values())
2762 +        for (boolean fFirst : new boolean[] { true, false })
2763 +        for (Integer v1 : new Integer[] { 1, null })
2764 +    {
2765 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
2766 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
2767 +        final CFException ex = new CFException();
2768 +        final Noop[] rs = new Noop[6];
2769 +        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2770 +
2771 +        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2772 +        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2773 +        assertTrue( fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2774 +        assertTrue(!fFirst ? f.complete(v1) : g.completeExceptionally(ex));
2775 +        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2776 +        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2777 +
2778 +        // unspecified behavior - both source completions available
2779 +        try {
2780 +            assertEquals(null, h0.join());
2781 +            rs[0].assertInvoked();
2782 +        } catch (CompletionException ok) {
2783 +            checkCompletedWithWrappedException(h0, ex);
2784 +            rs[0].assertNotInvoked();
2785 +        }
2786 +        try {
2787 +            assertEquals(null, h1.join());
2788 +            rs[1].assertInvoked();
2789 +        } catch (CompletionException ok) {
2790 +            checkCompletedWithWrappedException(h1, ex);
2791 +            rs[1].assertNotInvoked();
2792 +        }
2793 +        try {
2794 +            assertEquals(null, h2.join());
2795 +            rs[2].assertInvoked();
2796 +        } catch (CompletionException ok) {
2797 +            checkCompletedWithWrappedException(h2, ex);
2798 +            rs[2].assertNotInvoked();
2799 +        }
2800 +        try {
2801 +            assertEquals(null, h3.join());
2802 +            rs[3].assertInvoked();
2803 +        } catch (CompletionException ok) {
2804 +            checkCompletedWithWrappedException(h3, ex);
2805 +            rs[3].assertNotInvoked();
2806 +        }
2807 +
2808 +        checkCompletedNormally(f, v1);
2809 +        checkCompletedExceptionally(g, ex);
2810 +    }}
2811 +
2812      /**
2813       * runAfterEither result completes exceptionally if either source cancelled
2814       */
# Line 2395 | Line 2836 | public class CompletableFutureTest exten
2836          checkCompletedWithWrappedCancellationException(h2);
2837          checkCompletedWithWrappedCancellationException(h3);
2838  
2839 <        g.complete(v1);
2839 >        assertTrue(g.complete(v1));
2840  
2841          // unspecified behavior - both source completions available
2842          final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
# Line 2439 | Line 2880 | public class CompletableFutureTest exten
2880  
2881          final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2882          final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2883 <        f.complete(v1);
2883 >        assertTrue(f.complete(v1));
2884          final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2885          final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2886          checkCompletedWithWrappedCFException(h0);
# Line 2447 | Line 2888 | public class CompletableFutureTest exten
2888          checkCompletedWithWrappedCFException(h2);
2889          checkCompletedWithWrappedCFException(h3);
2890          for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2891 <        g.complete(v2);
2891 >        assertTrue(g.complete(v2));
2892          final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2893          final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2894          checkCompletedWithWrappedCFException(h4);
# Line 2468 | Line 2909 | public class CompletableFutureTest exten
2909      {
2910          final CompletableFuture<Integer> f = new CompletableFuture<>();
2911          final CompletableFutureInc r = new CompletableFutureInc(m);
2912 <        if (!createIncomplete) f.complete(v1);
2912 >        if (!createIncomplete) assertTrue(f.complete(v1));
2913          final CompletableFuture<Integer> g = m.thenCompose(f, r);
2914 <        if (createIncomplete) f.complete(v1);
2914 >        if (createIncomplete) assertTrue(f.complete(v1));
2915  
2916          checkCompletedNormally(g, inc(v1));
2917          checkCompletedNormally(f, v1);
2918 <        r.assertInvoked();
2918 >        r.assertValue(v1);
2919      }}
2920  
2921      /**
# Line 2492 | Line 2933 | public class CompletableFutureTest exten
2933          final CompletableFuture<Integer> g = m.thenCompose(f, r);
2934          if (createIncomplete) f.completeExceptionally(ex);
2935  
2936 <        checkCompletedWithWrappedCFException(g, ex);
2937 <        checkCompletedWithWrappedCFException(f, ex);
2936 >        checkCompletedWithWrappedException(g, ex);
2937 >        checkCompletedExceptionally(f, ex);
2938          r.assertNotInvoked();
2939      }}
2940  
# Line 2508 | Line 2949 | public class CompletableFutureTest exten
2949          final CompletableFuture<Integer> f = new CompletableFuture<>();
2950          final FailingCompletableFutureFunction r
2951              = new FailingCompletableFutureFunction(m);
2952 <        if (!createIncomplete) f.complete(v1);
2952 >        if (!createIncomplete) assertTrue(f.complete(v1));
2953          final CompletableFuture<Integer> g = m.thenCompose(f, r);
2954 <        if (createIncomplete) f.complete(v1);
2954 >        if (createIncomplete) assertTrue(f.complete(v1));
2955  
2956          checkCompletedWithWrappedCFException(g);
2957          checkCompletedNormally(f, v1);
# Line 2537 | Line 2978 | public class CompletableFutureTest exten
2978          checkCancelled(f);
2979      }}
2980  
2981 +    /**
2982 +     * thenCompose result completes exceptionally if the result of the action does
2983 +     */
2984 +    public void testThenCompose_actionReturnsFailingFuture() {
2985 +        for (ExecutionMode m : ExecutionMode.values())
2986 +        for (int order = 0; order < 6; order++)
2987 +        for (Integer v1 : new Integer[] { 1, null })
2988 +    {
2989 +        final CFException ex = new CFException();
2990 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
2991 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
2992 +        final CompletableFuture<Integer> h;
2993 +        // Test all permutations of orders
2994 +        switch (order) {
2995 +        case 0:
2996 +            assertTrue(f.complete(v1));
2997 +            assertTrue(g.completeExceptionally(ex));
2998 +            h = m.thenCompose(f, (x -> g));
2999 +            break;
3000 +        case 1:
3001 +            assertTrue(f.complete(v1));
3002 +            h = m.thenCompose(f, (x -> g));
3003 +            assertTrue(g.completeExceptionally(ex));
3004 +            break;
3005 +        case 2:
3006 +            assertTrue(g.completeExceptionally(ex));
3007 +            assertTrue(f.complete(v1));
3008 +            h = m.thenCompose(f, (x -> g));
3009 +            break;
3010 +        case 3:
3011 +            assertTrue(g.completeExceptionally(ex));
3012 +            h = m.thenCompose(f, (x -> g));
3013 +            assertTrue(f.complete(v1));
3014 +            break;
3015 +        case 4:
3016 +            h = m.thenCompose(f, (x -> g));
3017 +            assertTrue(f.complete(v1));
3018 +            assertTrue(g.completeExceptionally(ex));
3019 +            break;
3020 +        case 5:
3021 +            h = m.thenCompose(f, (x -> g));
3022 +            assertTrue(f.complete(v1));
3023 +            assertTrue(g.completeExceptionally(ex));
3024 +            break;
3025 +        default: throw new AssertionError();
3026 +        }
3027 +
3028 +        checkCompletedExceptionally(g, ex);
3029 +        checkCompletedWithWrappedException(h, ex);
3030 +        checkCompletedNormally(f, v1);
3031 +    }}
3032 +
3033      // other static methods
3034  
3035      /**
# Line 2553 | Line 3046 | public class CompletableFutureTest exten
3046       * when all components complete normally
3047       */
3048      public void testAllOf_normal() throws Exception {
3049 <        for (int k = 1; k < 20; ++k) {
3049 >        for (int k = 1; k < 10; k++) {
3050              CompletableFuture<Integer>[] fs
3051                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3052 <            for (int i = 0; i < k; ++i)
3052 >            for (int i = 0; i < k; i++)
3053                  fs[i] = new CompletableFuture<>();
3054              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3055 <            for (int i = 0; i < k; ++i) {
3055 >            for (int i = 0; i < k; i++) {
3056                  checkIncomplete(f);
3057                  checkIncomplete(CompletableFuture.allOf(fs));
3058                  fs[i].complete(one);
# Line 2570 | Line 3063 | public class CompletableFutureTest exten
3063      }
3064  
3065      public void testAllOf_backwards() throws Exception {
3066 <        for (int k = 1; k < 20; ++k) {
3066 >        for (int k = 1; k < 10; k++) {
3067              CompletableFuture<Integer>[] fs
3068                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3069 <            for (int i = 0; i < k; ++i)
3069 >            for (int i = 0; i < k; i++)
3070                  fs[i] = new CompletableFuture<>();
3071              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3072              for (int i = k - 1; i >= 0; i--) {
# Line 2586 | Line 3079 | public class CompletableFutureTest exten
3079          }
3080      }
3081  
3082 +    public void testAllOf_exceptional() throws Exception {
3083 +        for (int k = 1; k < 10; k++) {
3084 +            CompletableFuture<Integer>[] fs
3085 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3086 +            CFException ex = new CFException();
3087 +            for (int i = 0; i < k; i++)
3088 +                fs[i] = new CompletableFuture<>();
3089 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3090 +            for (int i = 0; i < k; i++) {
3091 +                checkIncomplete(f);
3092 +                checkIncomplete(CompletableFuture.allOf(fs));
3093 +                if (i != k / 2) {
3094 +                    fs[i].complete(i);
3095 +                    checkCompletedNormally(fs[i], i);
3096 +                } else {
3097 +                    fs[i].completeExceptionally(ex);
3098 +                    checkCompletedExceptionally(fs[i], ex);
3099 +                }
3100 +            }
3101 +            checkCompletedWithWrappedException(f, ex);
3102 +            checkCompletedWithWrappedException(CompletableFuture.allOf(fs), ex);
3103 +        }
3104 +    }
3105 +
3106      /**
3107       * anyOf(no component futures) returns an incomplete future
3108       */
3109      public void testAnyOf_empty() throws Exception {
3110 +        for (Integer v1 : new Integer[] { 1, null })
3111 +    {
3112          CompletableFuture<Object> f = CompletableFuture.anyOf();
3113          checkIncomplete(f);
3114 <    }
3114 >
3115 >        f.complete(v1);
3116 >        checkCompletedNormally(f, v1);
3117 >    }}
3118  
3119      /**
3120       * anyOf returns a future completed normally with a value when
3121       * a component future does
3122       */
3123      public void testAnyOf_normal() throws Exception {
3124 <        for (int k = 0; k < 10; ++k) {
3124 >        for (int k = 0; k < 10; k++) {
3125              CompletableFuture[] fs = new CompletableFuture[k];
3126 <            for (int i = 0; i < k; ++i)
3126 >            for (int i = 0; i < k; i++)
3127                  fs[i] = new CompletableFuture<>();
3128              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3129              checkIncomplete(f);
3130 <            for (int i = 0; i < k; ++i) {
3131 <                fs[i].complete(one);
3132 <                checkCompletedNormally(f, one);
3133 <                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
3130 >            for (int i = 0; i < k; i++) {
3131 >                fs[i].complete(i);
3132 >                checkCompletedNormally(f, 0);
3133 >                int x = (int) CompletableFuture.anyOf(fs).join();
3134 >                assertTrue(0 <= x && x <= i);
3135 >            }
3136 >        }
3137 >    }
3138 >    public void testAnyOf_normal_backwards() throws Exception {
3139 >        for (int k = 0; k < 10; k++) {
3140 >            CompletableFuture[] fs = new CompletableFuture[k];
3141 >            for (int i = 0; i < k; i++)
3142 >                fs[i] = new CompletableFuture<>();
3143 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3144 >            checkIncomplete(f);
3145 >            for (int i = k - 1; i >= 0; i--) {
3146 >                fs[i].complete(i);
3147 >                checkCompletedNormally(f, k - 1);
3148 >                int x = (int) CompletableFuture.anyOf(fs).join();
3149 >                assertTrue(i <= x && x <= k - 1);
3150              }
3151          }
3152      }
# Line 2617 | Line 3155 | public class CompletableFutureTest exten
3155       * anyOf result completes exceptionally when any component does.
3156       */
3157      public void testAnyOf_exceptional() throws Exception {
3158 <        for (int k = 0; k < 10; ++k) {
3158 >        for (int k = 0; k < 10; k++) {
3159              CompletableFuture[] fs = new CompletableFuture[k];
3160 <            for (int i = 0; i < k; ++i)
3160 >            CFException[] exs = new CFException[k];
3161 >            for (int i = 0; i < k; i++) {
3162                  fs[i] = new CompletableFuture<>();
3163 +                exs[i] = new CFException();
3164 +            }
3165              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3166              checkIncomplete(f);
3167 <            for (int i = 0; i < k; ++i) {
3168 <                fs[i].completeExceptionally(new CFException());
3169 <                checkCompletedWithWrappedCFException(f);
3167 >            for (int i = 0; i < k; i++) {
3168 >                fs[i].completeExceptionally(exs[i]);
3169 >                checkCompletedWithWrappedException(f, exs[0]);
3170 >                checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3171 >            }
3172 >        }
3173 >    }
3174 >
3175 >    public void testAnyOf_exceptional_backwards() throws Exception {
3176 >        for (int k = 0; k < 10; k++) {
3177 >            CompletableFuture[] fs = new CompletableFuture[k];
3178 >            CFException[] exs = new CFException[k];
3179 >            for (int i = 0; i < k; i++) {
3180 >                fs[i] = new CompletableFuture<>();
3181 >                exs[i] = new CFException();
3182 >            }
3183 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3184 >            checkIncomplete(f);
3185 >            for (int i = k - 1; i >= 0; i--) {
3186 >                fs[i].completeExceptionally(exs[i]);
3187 >                checkCompletedWithWrappedException(f, exs[k - 1]);
3188                  checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3189              }
3190          }
# Line 2638 | Line 3197 | public class CompletableFutureTest exten
3197          CompletableFuture<Integer> f = new CompletableFuture<>();
3198          CompletableFuture<Integer> g = new CompletableFuture<>();
3199          CompletableFuture<Integer> nullFuture = (CompletableFuture<Integer>)null;
2641 –        CompletableFuture<?> h;
3200          ThreadExecutor exec = new ThreadExecutor();
3201  
3202          Runnable[] throwingActions = {
3203              () -> CompletableFuture.supplyAsync(null),
3204              () -> CompletableFuture.supplyAsync(null, exec),
3205 <            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
3205 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.SYNC, 42), null),
3206  
3207              () -> CompletableFuture.runAsync(null),
3208              () -> CompletableFuture.runAsync(null, exec),
# Line 2735 | Line 3293 | public class CompletableFutureTest exten
3293              () -> CompletableFuture.anyOf(null, f),
3294  
3295              () -> f.obtrudeException(null),
3296 +
3297 +            () -> CompletableFuture.delayedExecutor(1L, SECONDS, null),
3298 +            () -> CompletableFuture.delayedExecutor(1L, null, new ThreadExecutor()),
3299 +            () -> CompletableFuture.delayedExecutor(1L, null),
3300 +
3301 +            () -> f.orTimeout(1L, null),
3302 +            () -> f.completeOnTimeout(42, 1L, null),
3303 +
3304 +            () -> CompletableFuture.failedFuture(null),
3305 +            () -> CompletableFuture.failedStage(null),
3306          };
3307  
3308          assertThrows(NullPointerException.class, throwingActions);
# Line 2749 | Line 3317 | public class CompletableFutureTest exten
3317          assertSame(f, f.toCompletableFuture());
3318      }
3319  
3320 +    // jdk9
3321 +
3322      /**
3323 <     * whenComplete action executes on normal completion, propagating
2754 <     * source result.
3323 >     * newIncompleteFuture returns an incomplete CompletableFuture
3324       */
3325 <    public void testWhenComplete_normalCompletion1() {
2757 <        for (ExecutionMode m : ExecutionMode.values())
2758 <        for (boolean createIncomplete : new boolean[] { true, false })
3325 >    public void testNewIncompleteFuture() {
3326          for (Integer v1 : new Integer[] { 1, null })
3327      {
3328 <        final AtomicInteger a = new AtomicInteger(0);
3329 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3330 <        if (!createIncomplete) f.complete(v1);
3331 <        final CompletableFuture<Integer> g = m.whenComplete
3332 <            (f,
2766 <             (Integer x, Throwable t) -> {
2767 <                threadAssertSame(x, v1);
2768 <                threadAssertNull(t);
2769 <                a.getAndIncrement();
2770 <            });
2771 <        if (createIncomplete) f.complete(v1);
2772 <
2773 <        checkCompletedNormally(g, v1);
3328 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3329 >        CompletableFuture<Integer> g = f.newIncompleteFuture();
3330 >        checkIncomplete(f);
3331 >        checkIncomplete(g);
3332 >        f.complete(v1);
3333          checkCompletedNormally(f, v1);
3334 <        assertEquals(1, a.get());
3334 >        checkIncomplete(g);
3335 >        g.complete(v1);
3336 >        checkCompletedNormally(g, v1);
3337 >        assertSame(g.getClass(), CompletableFuture.class);
3338      }}
3339  
3340      /**
3341 <     * whenComplete action executes on exceptional completion, propagating
2780 <     * source result.
3341 >     * completedStage returns a completed CompletionStage
3342       */
3343 <    public void testWhenComplete_exceptionalCompletion() {
3344 <        for (ExecutionMode m : ExecutionMode.values())
3345 <        for (boolean createIncomplete : new boolean[] { true, false })
3343 >    public void testCompletedStage() {
3344 >        AtomicInteger x = new AtomicInteger(0);
3345 >        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3346 >        CompletionStage<Integer> f = CompletableFuture.completedStage(1);
3347 >        f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3348 >        assertEquals(x.get(), 1);
3349 >        assertNull(r.get());
3350 >    }
3351 >
3352 >    /**
3353 >     * defaultExecutor by default returns the commonPool if
3354 >     * it supports more than one thread.
3355 >     */
3356 >    public void testDefaultExecutor() {
3357 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3358 >        Executor e = f.defaultExecutor();
3359 >        Executor c = ForkJoinPool.commonPool();
3360 >        if (ForkJoinPool.getCommonPoolParallelism() > 1)
3361 >            assertSame(e, c);
3362 >        else
3363 >            assertNotSame(e, c);
3364 >    }
3365 >
3366 >    /**
3367 >     * failedFuture returns a CompletableFuture completed
3368 >     * exceptionally with the given Exception
3369 >     */
3370 >    public void testFailedFuture() {
3371 >        CFException ex = new CFException();
3372 >        CompletableFuture<Integer> f = CompletableFuture.failedFuture(ex);
3373 >        checkCompletedExceptionally(f, ex);
3374 >    }
3375 >
3376 >    /**
3377 >     * failedFuture(null) throws NPE
3378 >     */
3379 >    public void testFailedFuture_null() {
3380 >        try {
3381 >            CompletableFuture<Integer> f = CompletableFuture.failedFuture(null);
3382 >            shouldThrow();
3383 >        } catch (NullPointerException success) {}
3384 >    }
3385 >
3386 >    /**
3387 >     * copy returns a CompletableFuture that is completed normally,
3388 >     * with the same value, when source is.
3389 >     */
3390 >    public void testCopy() {
3391 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3392 >        CompletableFuture<Integer> g = f.copy();
3393 >        checkIncomplete(f);
3394 >        checkIncomplete(g);
3395 >        f.complete(1);
3396 >        checkCompletedNormally(f, 1);
3397 >        checkCompletedNormally(g, 1);
3398 >    }
3399 >
3400 >    /**
3401 >     * copy returns a CompletableFuture that is completed exceptionally
3402 >     * when source is.
3403 >     */
3404 >    public void testCopy2() {
3405 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3406 >        CompletableFuture<Integer> g = f.copy();
3407 >        checkIncomplete(f);
3408 >        checkIncomplete(g);
3409 >        CFException ex = new CFException();
3410 >        f.completeExceptionally(ex);
3411 >        checkCompletedExceptionally(f, ex);
3412 >        checkCompletedWithWrappedException(g, ex);
3413 >    }
3414 >
3415 >    /**
3416 >     * minimalCompletionStage returns a CompletableFuture that is
3417 >     * completed normally, with the same value, when source is.
3418 >     */
3419 >    public void testMinimalCompletionStage() {
3420 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3421 >        CompletionStage<Integer> g = f.minimalCompletionStage();
3422 >        AtomicInteger x = new AtomicInteger(0);
3423 >        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3424 >        checkIncomplete(f);
3425 >        g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3426 >        f.complete(1);
3427 >        checkCompletedNormally(f, 1);
3428 >        assertEquals(x.get(), 1);
3429 >        assertNull(r.get());
3430 >    }
3431 >
3432 >    /**
3433 >     * minimalCompletionStage returns a CompletableFuture that is
3434 >     * completed exceptionally when source is.
3435 >     */
3436 >    public void testMinimalCompletionStage2() {
3437 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3438 >        CompletionStage<Integer> g = f.minimalCompletionStage();
3439 >        AtomicInteger x = new AtomicInteger(0);
3440 >        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3441 >        g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3442 >        checkIncomplete(f);
3443 >        CFException ex = new CFException();
3444 >        f.completeExceptionally(ex);
3445 >        checkCompletedExceptionally(f, ex);
3446 >        assertEquals(x.get(), 0);
3447 >        assertEquals(r.get().getCause(), ex);
3448 >    }
3449 >
3450 >    /**
3451 >     * failedStage returns a CompletionStage completed
3452 >     * exceptionally with the given Exception
3453 >     */
3454 >    public void testFailedStage() {
3455 >        CFException ex = new CFException();
3456 >        CompletionStage<Integer> f = CompletableFuture.failedStage(ex);
3457 >        AtomicInteger x = new AtomicInteger(0);
3458 >        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3459 >        f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3460 >        assertEquals(x.get(), 0);
3461 >        assertEquals(r.get(), ex);
3462 >    }
3463 >
3464 >    /**
3465 >     * completeAsync completes with value of given supplier
3466 >     */
3467 >    public void testCompleteAsync() {
3468          for (Integer v1 : new Integer[] { 1, null })
3469      {
3470 <        final AtomicInteger a = new AtomicInteger(0);
3471 <        final CFException ex = new CFException();
3472 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3473 <        if (!createIncomplete) f.completeExceptionally(ex);
2791 <        final CompletableFuture<Integer> g = m.whenComplete
2792 <            (f,
2793 <             (Integer x, Throwable t) -> {
2794 <                threadAssertNull(x);
2795 <                threadAssertSame(t, ex);
2796 <                a.getAndIncrement();
2797 <            });
2798 <        if (createIncomplete) f.completeExceptionally(ex);
2799 <        checkCompletedWithWrappedCFException(f, ex);
2800 <        checkCompletedWithWrappedCFException(g, ex);
2801 <        assertEquals(1, a.get());
3470 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3471 >        f.completeAsync(() -> v1);
3472 >        f.join();
3473 >        checkCompletedNormally(f, v1);
3474      }}
3475  
3476      /**
3477 <     * whenComplete action executes on cancelled source, propagating
2806 <     * CancellationException.
3477 >     * completeAsync completes exceptionally if given supplier throws
3478       */
3479 <    public void testWhenComplete_sourceCancelled() {
3480 <        for (ExecutionMode m : ExecutionMode.values())
3481 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3482 <        for (boolean createIncomplete : new boolean[] { true, false })
3479 >    public void testCompleteAsync2() {
3480 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3481 >        CFException ex = new CFException();
3482 >        f.completeAsync(() -> {if (true) throw ex; return 1;});
3483 >        try {
3484 >            f.join();
3485 >            shouldThrow();
3486 >        } catch (CompletionException success) {}
3487 >        checkCompletedWithWrappedException(f, ex);
3488 >    }
3489 >
3490 >    /**
3491 >     * completeAsync with given executor completes with value of given supplier
3492 >     */
3493 >    public void testCompleteAsync3() {
3494 >        for (Integer v1 : new Integer[] { 1, null })
3495      {
3496 <        final AtomicInteger a = new AtomicInteger(0);
3497 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3498 <        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3499 <        final CompletableFuture<Integer> g = m.whenComplete
3500 <            (f,
3501 <             (Integer x, Throwable t) -> {
3502 <                threadAssertNull(x);
2820 <                threadAssertTrue(t instanceof CancellationException);
2821 <                a.getAndIncrement();
2822 <            });
2823 <        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3496 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3497 >        ThreadExecutor executor = new ThreadExecutor();
3498 >        f.completeAsync(() -> v1, executor);
3499 >        assertSame(v1, f.join());
3500 >        checkCompletedNormally(f, v1);
3501 >        assertEquals(1, executor.count.get());
3502 >    }}
3503  
3504 <        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
3505 <        checkCompletedWithWrappedCancellationException(g);
3506 <        checkCancelled(f);
3507 <        assertEquals(1, a.get());
3504 >    /**
3505 >     * completeAsync with given executor completes exceptionally if
3506 >     * given supplier throws
3507 >     */
3508 >    public void testCompleteAsync4() {
3509 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3510 >        CFException ex = new CFException();
3511 >        ThreadExecutor executor = new ThreadExecutor();
3512 >        f.completeAsync(() -> {if (true) throw ex; return 1;}, executor);
3513 >        try {
3514 >            f.join();
3515 >            shouldThrow();
3516 >        } catch (CompletionException success) {}
3517 >        checkCompletedWithWrappedException(f, ex);
3518 >        assertEquals(1, executor.count.get());
3519 >    }
3520 >
3521 >    /**
3522 >     * orTimeout completes with TimeoutException if not complete
3523 >     */
3524 >    public void testOrTimeout_timesOut() {
3525 >        long timeoutMillis = timeoutMillis();
3526 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3527 >        long startTime = System.nanoTime();
3528 >        f.orTimeout(timeoutMillis, MILLISECONDS);
3529 >        checkCompletedWithTimeoutException(f);
3530 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
3531 >    }
3532 >
3533 >    /**
3534 >     * orTimeout completes normally if completed before timeout
3535 >     */
3536 >    public void testOrTimeout_completed() {
3537 >        for (Integer v1 : new Integer[] { 1, null })
3538 >    {
3539 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3540 >        CompletableFuture<Integer> g = new CompletableFuture<>();
3541 >        long startTime = System.nanoTime();
3542 >        f.complete(v1);
3543 >        f.orTimeout(LONG_DELAY_MS, MILLISECONDS);
3544 >        g.orTimeout(LONG_DELAY_MS, MILLISECONDS);
3545 >        g.complete(v1);
3546 >        checkCompletedNormally(f, v1);
3547 >        checkCompletedNormally(g, v1);
3548 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
3549      }}
3550  
3551      /**
3552 <     * If a whenComplete action throws an exception when triggered by
2833 <     * a normal completion, it completes exceptionally
3552 >     * completeOnTimeout completes with given value if not complete
3553       */
3554 <    public void testWhenComplete_actionFailed() {
3555 <        for (boolean createIncomplete : new boolean[] { true, false })
3556 <        for (ExecutionMode m : ExecutionMode.values())
3554 >    public void testCompleteOnTimeout_timesOut() {
3555 >        testInParallel(() -> testCompleteOnTimeout_timesOut(42),
3556 >                       () -> testCompleteOnTimeout_timesOut(null));
3557 >    }
3558 >
3559 >    public void testCompleteOnTimeout_timesOut(Integer v) {
3560 >        long timeoutMillis = timeoutMillis();
3561 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3562 >        long startTime = System.nanoTime();
3563 >        f.completeOnTimeout(v, timeoutMillis, MILLISECONDS);
3564 >        assertSame(v, f.join());
3565 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
3566 >        f.complete(99);         // should have no effect
3567 >        checkCompletedNormally(f, v);
3568 >    }
3569 >
3570 >    /**
3571 >     * completeOnTimeout has no effect if completed within timeout
3572 >     */
3573 >    public void testCompleteOnTimeout_completed() {
3574          for (Integer v1 : new Integer[] { 1, null })
3575      {
3576 <        final AtomicInteger a = new AtomicInteger(0);
3577 <        final CFException ex = new CFException();
3578 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3579 <        if (!createIncomplete) f.complete(v1);
3580 <        final CompletableFuture<Integer> g = m.whenComplete
3581 <            (f,
3582 <             (Integer x, Throwable t) -> {
2847 <                threadAssertSame(x, v1);
2848 <                threadAssertNull(t);
2849 <                a.getAndIncrement();
2850 <                throw ex;
2851 <            });
2852 <        if (createIncomplete) f.complete(v1);
3576 >        CompletableFuture<Integer> f = new CompletableFuture<>();
3577 >        CompletableFuture<Integer> g = new CompletableFuture<>();
3578 >        long startTime = System.nanoTime();
3579 >        f.complete(v1);
3580 >        f.completeOnTimeout(-1, LONG_DELAY_MS, MILLISECONDS);
3581 >        g.completeOnTimeout(-1, LONG_DELAY_MS, MILLISECONDS);
3582 >        g.complete(v1);
3583          checkCompletedNormally(f, v1);
3584 <        checkCompletedWithWrappedCFException(g, ex);
3585 <        assertEquals(1, a.get());
3584 >        checkCompletedNormally(g, v1);
3585 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
3586      }}
3587  
3588      /**
3589 <     * If a whenComplete action throws an exception when triggered by
2860 <     * a source completion that also throws an exception, the source
2861 <     * exception takes precedence.
3589 >     * delayedExecutor returns an executor that delays submission
3590       */
3591 <    public void testWhenComplete_actionFailedSourceFailed() {
3592 <        for (boolean createIncomplete : new boolean[] { true, false })
3591 >    public void testDelayedExecutor() {
3592 >        testInParallel(() -> testDelayedExecutor(null, null),
3593 >                       () -> testDelayedExecutor(null, 1),
3594 >                       () -> testDelayedExecutor(new ThreadExecutor(), 1),
3595 >                       () -> testDelayedExecutor(new ThreadExecutor(), 1));
3596 >    }
3597 >
3598 >    public void testDelayedExecutor(Executor executor, Integer v) throws Exception {
3599 >        long timeoutMillis = timeoutMillis();
3600 >        // Use an "unreasonably long" long timeout to catch lingering threads
3601 >        long longTimeoutMillis = 1000 * 60 * 60 * 24;
3602 >        final Executor delayer, longDelayer;
3603 >        if (executor == null) {
3604 >            delayer = CompletableFuture.delayedExecutor(timeoutMillis, MILLISECONDS);
3605 >            longDelayer = CompletableFuture.delayedExecutor(longTimeoutMillis, MILLISECONDS);
3606 >        } else {
3607 >            delayer = CompletableFuture.delayedExecutor(timeoutMillis, MILLISECONDS, executor);
3608 >            longDelayer = CompletableFuture.delayedExecutor(longTimeoutMillis, MILLISECONDS, executor);
3609 >        }
3610 >        long startTime = System.nanoTime();
3611 >        CompletableFuture<Integer> f =
3612 >            CompletableFuture.supplyAsync(() -> v, delayer);
3613 >        CompletableFuture<Integer> g =
3614 >            CompletableFuture.supplyAsync(() -> v, longDelayer);
3615 >
3616 >        assertNull(g.getNow(null));
3617 >
3618 >        assertSame(v, f.get(LONG_DELAY_MS, MILLISECONDS));
3619 >        long millisElapsed = millisElapsedSince(startTime);
3620 >        assertTrue(millisElapsed >= timeoutMillis);
3621 >        assertTrue(millisElapsed < LONG_DELAY_MS / 2);
3622 >
3623 >        checkCompletedNormally(f, v);
3624 >
3625 >        checkIncomplete(g);
3626 >        assertTrue(g.cancel(true));
3627 >    }
3628 >
3629 >    //--- tests of implementation details; not part of official tck ---
3630 >
3631 >    Object resultOf(CompletableFuture<?> f) {
3632 >        try {
3633 >            java.lang.reflect.Field resultField
3634 >                = CompletableFuture.class.getDeclaredField("result");
3635 >            resultField.setAccessible(true);
3636 >            return resultField.get(f);
3637 >        } catch (Throwable t) { throw new AssertionError(t); }
3638 >    }
3639 >
3640 >    public void testExceptionPropagationReusesResultObject() {
3641 >        if (!testImplementationDetails) return;
3642          for (ExecutionMode m : ExecutionMode.values())
2866 –        for (Integer v1 : new Integer[] { 1, null })
3643      {
3644 <        final AtomicInteger a = new AtomicInteger(0);
3645 <        final CFException ex1 = new CFException();
3646 <        final CFException ex2 = new CFException();
2871 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
3644 >        final CFException ex = new CFException();
3645 >        final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3646 >        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3647  
3648 <        if (!createIncomplete) f.completeExceptionally(ex1);
3649 <        final CompletableFuture<Integer> g = m.whenComplete
2875 <            (f,
2876 <             (Integer x, Throwable t) -> {
2877 <                threadAssertSame(t, ex1);
2878 <                threadAssertNull(x);
2879 <                a.getAndIncrement();
2880 <                throw ex2;
2881 <            });
2882 <        if (createIncomplete) f.completeExceptionally(ex1);
3648 >        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3649 >            = new ArrayList<>();
3650  
3651 <        checkCompletedWithWrappedCFException(f, ex1);
3652 <        checkCompletedWithWrappedCFException(g, ex1);
3653 <        assertEquals(1, a.get());
3651 >        funs.add((y) -> m.thenRun(y, new Noop(m)));
3652 >        funs.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3653 >        funs.add((y) -> m.thenApply(y, new IncFunction(m)));
3654 >
3655 >        funs.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3656 >        funs.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3657 >        funs.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3658 >
3659 >        funs.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3660 >        funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3661 >        funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3662 >
3663 >        funs.add((y) -> m.whenComplete(y, (Integer r, Throwable t) -> {}));
3664 >
3665 >        funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3666 >
3667 >        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
3668 >        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
3669 >
3670 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3671 >                 fun : funs) {
3672 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3673 >            f.completeExceptionally(ex);
3674 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3675 >            checkCompletedWithWrappedException(src, ex);
3676 >            CompletableFuture<?> dep = fun.apply(src);
3677 >            checkCompletedWithWrappedException(dep, ex);
3678 >            assertSame(resultOf(src), resultOf(dep));
3679 >        }
3680 >
3681 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3682 >                 fun : funs) {
3683 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3684 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3685 >            CompletableFuture<?> dep = fun.apply(src);
3686 >            f.completeExceptionally(ex);
3687 >            checkCompletedWithWrappedException(src, ex);
3688 >            checkCompletedWithWrappedException(dep, ex);
3689 >            assertSame(resultOf(src), resultOf(dep));
3690 >        }
3691 >
3692 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3693 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3694 >                 fun : funs) {
3695 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3696 >            f.cancel(mayInterruptIfRunning);
3697 >            checkCancelled(f);
3698 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3699 >            checkCompletedWithWrappedCancellationException(src);
3700 >            CompletableFuture<?> dep = fun.apply(src);
3701 >            checkCompletedWithWrappedCancellationException(dep);
3702 >            assertSame(resultOf(src), resultOf(dep));
3703 >        }
3704 >
3705 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3706 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3707 >                 fun : funs) {
3708 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3709 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3710 >            CompletableFuture<?> dep = fun.apply(src);
3711 >            f.cancel(mayInterruptIfRunning);
3712 >            checkCancelled(f);
3713 >            checkCompletedWithWrappedCancellationException(src);
3714 >            checkCompletedWithWrappedCancellationException(dep);
3715 >            assertSame(resultOf(src), resultOf(dep));
3716 >        }
3717      }}
3718  
3719 +    /**
3720 +     * Minimal completion stages throw UOE for all non-CompletionStage methods
3721 +     */
3722 +    public void testMinimalCompletionStage_minimality() {
3723 +        if (!testImplementationDetails) return;
3724 +        Function<Method, String> toSignature =
3725 +            (method) -> method.getName() + Arrays.toString(method.getParameterTypes());
3726 +        Predicate<Method> isNotStatic =
3727 +            (method) -> (method.getModifiers() & Modifier.STATIC) == 0;
3728 +        List<Method> minimalMethods =
3729 +            Stream.of(Object.class, CompletionStage.class)
3730 +            .flatMap((klazz) -> Stream.of(klazz.getMethods()))
3731 +            .filter(isNotStatic)
3732 +            .collect(Collectors.toList());
3733 +        // Methods from CompletableFuture permitted NOT to throw UOE
3734 +        String[] signatureWhitelist = {
3735 +            "newIncompleteFuture[]",
3736 +            "defaultExecutor[]",
3737 +            "minimalCompletionStage[]",
3738 +            "copy[]",
3739 +        };
3740 +        Set<String> permittedMethodSignatures =
3741 +            Stream.concat(minimalMethods.stream().map(toSignature),
3742 +                          Stream.of(signatureWhitelist))
3743 +            .collect(Collectors.toSet());
3744 +        List<Method> allMethods = Stream.of(CompletableFuture.class.getMethods())
3745 +            .filter(isNotStatic)
3746 +            .filter((method) -> !permittedMethodSignatures.contains(toSignature.apply(method)))
3747 +            .collect(Collectors.toList());
3748 +
3749 +        CompletionStage<Integer> minimalStage =
3750 +            new CompletableFuture<Integer>().minimalCompletionStage();
3751 +
3752 +        List<Method> bugs = new ArrayList<>();
3753 +        for (Method method : allMethods) {
3754 +            Class<?>[] parameterTypes = method.getParameterTypes();
3755 +            Object[] args = new Object[parameterTypes.length];
3756 +            // Manufacture boxed primitives for primitive params
3757 +            for (int i = 0; i < args.length; i++) {
3758 +                Class<?> type = parameterTypes[i];
3759 +                if (parameterTypes[i] == boolean.class)
3760 +                    args[i] = false;
3761 +                else if (parameterTypes[i] == int.class)
3762 +                    args[i] = 0;
3763 +                else if (parameterTypes[i] == long.class)
3764 +                    args[i] = 0L;
3765 +            }
3766 +            try {
3767 +                method.invoke(minimalStage, args);
3768 +                bugs.add(method);
3769 +            }
3770 +            catch (java.lang.reflect.InvocationTargetException expected) {
3771 +                if (! (expected.getCause() instanceof UnsupportedOperationException)) {
3772 +                    bugs.add(method);
3773 +                    // expected.getCause().printStackTrace();
3774 +                }
3775 +            }
3776 +            catch (ReflectiveOperationException bad) { throw new Error(bad); }
3777 +        }
3778 +        if (!bugs.isEmpty())
3779 +            throw new Error("Methods did not throw UOE: " + bugs.toString());
3780 +    }
3781 +
3782 +    static class Monad {
3783 +        static class ZeroException extends RuntimeException {
3784 +            public ZeroException() { super("monadic zero"); }
3785 +        }
3786 +        // "return", "unit"
3787 +        static <T> CompletableFuture<T> unit(T value) {
3788 +            return completedFuture(value);
3789 +        }
3790 +        // monadic zero ?
3791 +        static <T> CompletableFuture<T> zero() {
3792 +            return failedFuture(new ZeroException());
3793 +        }
3794 +        // >=>
3795 +        static <T,U,V> Function<T, CompletableFuture<V>> compose
3796 +            (Function<T, CompletableFuture<U>> f,
3797 +             Function<U, CompletableFuture<V>> g) {
3798 +            return (x) -> f.apply(x).thenCompose(g);
3799 +        }
3800 +
3801 +        static void assertZero(CompletableFuture<?> f) {
3802 +            try {
3803 +                f.getNow(null);
3804 +                throw new AssertionFailedError("should throw");
3805 +            } catch (CompletionException success) {
3806 +                assertTrue(success.getCause() instanceof ZeroException);
3807 +            }
3808 +        }
3809 +
3810 +        static <T> void assertFutureEquals(CompletableFuture<T> f,
3811 +                                           CompletableFuture<T> g) {
3812 +            T fval = null, gval = null;
3813 +            Throwable fex = null, gex = null;
3814 +
3815 +            try { fval = f.get(); }
3816 +            catch (ExecutionException ex) { fex = ex.getCause(); }
3817 +            catch (Throwable ex) { fex = ex; }
3818 +
3819 +            try { gval = g.get(); }
3820 +            catch (ExecutionException ex) { gex = ex.getCause(); }
3821 +            catch (Throwable ex) { gex = ex; }
3822 +
3823 +            if (fex != null || gex != null)
3824 +                assertSame(fex.getClass(), gex.getClass());
3825 +            else
3826 +                assertEquals(fval, gval);
3827 +        }
3828 +
3829 +        static class PlusFuture<T> extends CompletableFuture<T> {
3830 +            AtomicReference<Throwable> firstFailure = new AtomicReference<>(null);
3831 +        }
3832 +
3833 +        /** Implements "monadic plus". */
3834 +        static <T> CompletableFuture<T> plus(CompletableFuture<? extends T> f,
3835 +                                             CompletableFuture<? extends T> g) {
3836 +            PlusFuture<T> plus = new PlusFuture<T>();
3837 +            BiConsumer<T, Throwable> action = (T result, Throwable ex) -> {
3838 +                try {
3839 +                    if (ex == null) {
3840 +                        if (plus.complete(result))
3841 +                            if (plus.firstFailure.get() != null)
3842 +                                plus.firstFailure.set(null);
3843 +                    }
3844 +                    else if (plus.firstFailure.compareAndSet(null, ex)) {
3845 +                        if (plus.isDone())
3846 +                            plus.firstFailure.set(null);
3847 +                    }
3848 +                    else {
3849 +                        // first failure has precedence
3850 +                        Throwable first = plus.firstFailure.getAndSet(null);
3851 +
3852 +                        // may fail with "Self-suppression not permitted"
3853 +                        try { first.addSuppressed(ex); }
3854 +                        catch (Exception ignored) {}
3855 +
3856 +                        plus.completeExceptionally(first);
3857 +                    }
3858 +                } catch (Throwable unexpected) {
3859 +                    plus.completeExceptionally(unexpected);
3860 +                }
3861 +            };
3862 +            f.whenComplete(action);
3863 +            g.whenComplete(action);
3864 +            return plus;
3865 +        }
3866 +    }
3867 +
3868 +    /**
3869 +     * CompletableFuture is an additive monad - sort of.
3870 +     * https://en.wikipedia.org/wiki/Monad_(functional_programming)#Additive_monads
3871 +     */
3872 +    public void testAdditiveMonad() throws Throwable {
3873 +        Function<Long, CompletableFuture<Long>> unit = Monad::unit;
3874 +        CompletableFuture<Long> zero = Monad.zero();
3875 +
3876 +        // Some mutually non-commutative functions
3877 +        Function<Long, CompletableFuture<Long>> triple
3878 +            = (x) -> Monad.unit(3 * x);
3879 +        Function<Long, CompletableFuture<Long>> inc
3880 +            = (x) -> Monad.unit(x + 1);
3881 +
3882 +        // unit is a right identity: m >>= unit === m
3883 +        Monad.assertFutureEquals(inc.apply(5L).thenCompose(unit),
3884 +                                 inc.apply(5L));
3885 +        // unit is a left identity: (unit x) >>= f === f x
3886 +        Monad.assertFutureEquals(unit.apply(5L).thenCompose(inc),
3887 +                                 inc.apply(5L));
3888 +
3889 +        // associativity: (m >>= f) >>= g === m >>= ( \x -> (f x >>= g) )
3890 +        Monad.assertFutureEquals(
3891 +            unit.apply(5L).thenCompose(inc).thenCompose(triple),
3892 +            unit.apply(5L).thenCompose((x) -> inc.apply(x).thenCompose(triple)));
3893 +
3894 +        // The case for CompletableFuture as an additive monad is weaker...
3895 +
3896 +        // zero is a monadic zero
3897 +        Monad.assertZero(zero);
3898 +
3899 +        // left zero: zero >>= f === zero
3900 +        Monad.assertZero(zero.thenCompose(inc));
3901 +        // right zero: f >>= (\x -> zero) === zero
3902 +        Monad.assertZero(inc.apply(5L).thenCompose((x) -> zero));
3903 +
3904 +        // f plus zero === f
3905 +        Monad.assertFutureEquals(Monad.unit(5L),
3906 +                                 Monad.plus(Monad.unit(5L), zero));
3907 +        // zero plus f === f
3908 +        Monad.assertFutureEquals(Monad.unit(5L),
3909 +                                 Monad.plus(zero, Monad.unit(5L)));
3910 +        // zero plus zero === zero
3911 +        Monad.assertZero(Monad.plus(zero, zero));
3912 +        {
3913 +            CompletableFuture<Long> f = Monad.plus(Monad.unit(5L),
3914 +                                                   Monad.unit(8L));
3915 +            // non-determinism
3916 +            assertTrue(f.get() == 5L || f.get() == 8L);
3917 +        }
3918 +
3919 +        CompletableFuture<Long> godot = new CompletableFuture<>();
3920 +        // f plus godot === f (doesn't wait for godot)
3921 +        Monad.assertFutureEquals(Monad.unit(5L),
3922 +                                 Monad.plus(Monad.unit(5L), godot));
3923 +        // godot plus f === f (doesn't wait for godot)
3924 +        Monad.assertFutureEquals(Monad.unit(5L),
3925 +                                 Monad.plus(godot, Monad.unit(5L)));
3926 +    }
3927 +
3928 +    /**
3929 +     * A single CompletableFuture with many dependents.
3930 +     * A demo of scalability - runtime is O(n).
3931 +     */
3932 +    public void testManyDependents() throws Throwable {
3933 +        final int n = 1_000;
3934 +        final CompletableFuture<Void> head = new CompletableFuture<>();
3935 +        final CompletableFuture<Void> complete = CompletableFuture.completedFuture((Void)null);
3936 +        final AtomicInteger count = new AtomicInteger(0);
3937 +        for (int i = 0; i < n; i++) {
3938 +            head.thenRun(() -> count.getAndIncrement());
3939 +            head.thenAccept((x) -> count.getAndIncrement());
3940 +            head.thenApply((x) -> count.getAndIncrement());
3941 +
3942 +            head.runAfterBoth(complete, () -> count.getAndIncrement());
3943 +            head.thenAcceptBoth(complete, (x, y) -> count.getAndIncrement());
3944 +            head.thenCombine(complete, (x, y) -> count.getAndIncrement());
3945 +            complete.runAfterBoth(head, () -> count.getAndIncrement());
3946 +            complete.thenAcceptBoth(head, (x, y) -> count.getAndIncrement());
3947 +            complete.thenCombine(head, (x, y) -> count.getAndIncrement());
3948 +
3949 +            head.runAfterEither(new CompletableFuture<Void>(), () -> count.getAndIncrement());
3950 +            head.acceptEither(new CompletableFuture<Void>(), (x) -> count.getAndIncrement());
3951 +            head.applyToEither(new CompletableFuture<Void>(), (x) -> count.getAndIncrement());
3952 +            new CompletableFuture<Void>().runAfterEither(head, () -> count.getAndIncrement());
3953 +            new CompletableFuture<Void>().acceptEither(head, (x) -> count.getAndIncrement());
3954 +            new CompletableFuture<Void>().applyToEither(head, (x) -> count.getAndIncrement());
3955 +        }
3956 +        head.complete(null);
3957 +        assertEquals(5 * 3 * n, count.get());
3958 +    }
3959 +
3960 + //     static <U> U join(CompletionStage<U> stage) {
3961 + //         CompletableFuture<U> f = new CompletableFuture<>();
3962 + //         stage.whenComplete((v, ex) -> {
3963 + //             if (ex != null) f.completeExceptionally(ex); else f.complete(v);
3964 + //         });
3965 + //         return f.join();
3966 + //     }
3967 +
3968 + //     static <U> boolean isDone(CompletionStage<U> stage) {
3969 + //         CompletableFuture<U> f = new CompletableFuture<>();
3970 + //         stage.whenComplete((v, ex) -> {
3971 + //             if (ex != null) f.completeExceptionally(ex); else f.complete(v);
3972 + //         });
3973 + //         return f.isDone();
3974 + //     }
3975 +
3976 + //     static <U> U join2(CompletionStage<U> stage) {
3977 + //         return stage.toCompletableFuture().copy().join();
3978 + //     }
3979 +
3980 + //     static <U> boolean isDone2(CompletionStage<U> stage) {
3981 + //         return stage.toCompletableFuture().copy().isDone();
3982 + //     }
3983 +
3984   }

Diff Legend

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