ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CompletableFutureTest.java
Revision: 1.36
Committed: Sun Jun 1 23:12:45 2014 UTC (9 years, 11 months ago) by jsr166
Branch: MAIN
Changes since 1.35: +304 -329 lines
Log Message: 
improve tests for thenCombine

File Contents

# User Rev Content
1 jsr166 1.1 /*
2 jsr166 1.4 * Written by Doug Lea and Martin Buchholz with assistance from
3     * members of JCP JSR-166 Expert Group and released to the public
4     * domain, as explained at
5 jsr166 1.1 * http://creativecommons.org/publicdomain/zero/1.0/
6     */
7    
8     import junit.framework.*;
9     import java.util.concurrent.Callable;
10 dl 1.5 import java.util.concurrent.Executor;
11     import java.util.concurrent.ExecutorService;
12     import java.util.concurrent.Executors;
13 jsr166 1.1 import java.util.concurrent.CancellationException;
14     import java.util.concurrent.CountDownLatch;
15     import java.util.concurrent.ExecutionException;
16     import java.util.concurrent.Future;
17     import java.util.concurrent.CompletableFuture;
18 dl 1.5 import java.util.concurrent.CompletionException;
19 jsr166 1.35 import java.util.concurrent.CompletionStage;
20 jsr166 1.1 import java.util.concurrent.TimeoutException;
21     import java.util.concurrent.atomic.AtomicInteger;
22     import static java.util.concurrent.TimeUnit.MILLISECONDS;
23     import static java.util.concurrent.TimeUnit.SECONDS;
24     import java.util.*;
25 dl 1.5 import java.util.function.Supplier;
26     import java.util.function.Consumer;
27     import java.util.function.BiConsumer;
28     import java.util.function.Function;
29     import java.util.function.BiFunction;
30 jsr166 1.1
31     public class CompletableFutureTest extends JSR166TestCase {
32    
33     public static void main(String[] args) {
34     junit.textui.TestRunner.run(suite());
35     }
36     public static Test suite() {
37     return new TestSuite(CompletableFutureTest.class);
38     }
39    
40 dl 1.5 static class CFException extends RuntimeException {}
41    
42 jsr166 1.4 void checkIncomplete(CompletableFuture<?> f) {
43     assertFalse(f.isDone());
44     assertFalse(f.isCancelled());
45     assertTrue(f.toString().contains("[Not completed]"));
46     try {
47     assertNull(f.getNow(null));
48     } catch (Throwable fail) { threadUnexpectedException(fail); }
49     try {
50     f.get(0L, SECONDS);
51     shouldThrow();
52     }
53     catch (TimeoutException success) {}
54     catch (Throwable fail) { threadUnexpectedException(fail); }
55     }
56    
57 jsr166 1.11 <T> void checkCompletedNormally(CompletableFuture<T> f, T value) {
58 jsr166 1.4 try {
59 jsr166 1.20 assertEquals(value, f.get(LONG_DELAY_MS, MILLISECONDS));
60     } catch (Throwable fail) { threadUnexpectedException(fail); }
61     try {
62 dl 1.5 assertEquals(value, f.join());
63 jsr166 1.4 } catch (Throwable fail) { threadUnexpectedException(fail); }
64     try {
65 dl 1.5 assertEquals(value, f.getNow(null));
66 jsr166 1.4 } catch (Throwable fail) { threadUnexpectedException(fail); }
67     try {
68 dl 1.5 assertEquals(value, f.get());
69 jsr166 1.4 } catch (Throwable fail) { threadUnexpectedException(fail); }
70 dl 1.5 assertTrue(f.isDone());
71     assertFalse(f.isCancelled());
72 dl 1.26 assertFalse(f.isCompletedExceptionally());
73 dl 1.5 assertTrue(f.toString().contains("[Completed normally]"));
74     }
75    
76     void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
77     try {
78 jsr166 1.20 f.get(LONG_DELAY_MS, MILLISECONDS);
79     shouldThrow();
80     } catch (ExecutionException success) {
81     assertTrue(success.getCause() instanceof CFException);
82     } catch (Throwable fail) { threadUnexpectedException(fail); }
83     try {
84 dl 1.5 f.join();
85     shouldThrow();
86 jsr166 1.8 } catch (CompletionException success) {
87     assertTrue(success.getCause() instanceof CFException);
88 dl 1.5 }
89     try {
90     f.getNow(null);
91     shouldThrow();
92 jsr166 1.8 } catch (CompletionException success) {
93     assertTrue(success.getCause() instanceof CFException);
94 dl 1.5 }
95     try {
96     f.get();
97     shouldThrow();
98 jsr166 1.8 } catch (ExecutionException success) {
99     assertTrue(success.getCause() instanceof CFException);
100     } catch (Throwable fail) { threadUnexpectedException(fail); }
101 dl 1.5 assertTrue(f.isDone());
102     assertFalse(f.isCancelled());
103 jsr166 1.14 assertTrue(f.toString().contains("[Completed exceptionally]"));
104 dl 1.5 }
105    
106 jsr166 1.33 void checkCompletedWithWrappedCFException(CompletableFuture<?> f,
107     CFException ex) {
108     try {
109     f.get(LONG_DELAY_MS, MILLISECONDS);
110     shouldThrow();
111     } catch (ExecutionException success) {
112     assertSame(ex, success.getCause());
113     } catch (Throwable fail) { threadUnexpectedException(fail); }
114     try {
115     f.join();
116     shouldThrow();
117     } catch (CompletionException success) {
118     assertSame(ex, success.getCause());
119     }
120     try {
121     f.getNow(null);
122     shouldThrow();
123     } catch (CompletionException success) {
124     assertSame(ex, success.getCause());
125     }
126     try {
127     f.get();
128     shouldThrow();
129     } catch (ExecutionException success) {
130     assertSame(ex, success.getCause());
131     } catch (Throwable fail) { threadUnexpectedException(fail); }
132     assertTrue(f.isDone());
133     assertFalse(f.isCancelled());
134     assertTrue(f.toString().contains("[Completed exceptionally]"));
135     }
136    
137 dl 1.5 void checkCancelled(CompletableFuture<?> f) {
138     try {
139 jsr166 1.20 f.get(LONG_DELAY_MS, MILLISECONDS);
140     shouldThrow();
141     } catch (CancellationException success) {
142     } catch (Throwable fail) { threadUnexpectedException(fail); }
143     try {
144 dl 1.5 f.join();
145     shouldThrow();
146 jsr166 1.8 } catch (CancellationException success) {}
147 dl 1.5 try {
148     f.getNow(null);
149     shouldThrow();
150 jsr166 1.8 } catch (CancellationException success) {}
151 dl 1.5 try {
152     f.get();
153     shouldThrow();
154 jsr166 1.8 } catch (CancellationException success) {
155     } catch (Throwable fail) { threadUnexpectedException(fail); }
156 dl 1.5 assertTrue(f.isDone());
157 dl 1.26 assertTrue(f.isCompletedExceptionally());
158 dl 1.5 assertTrue(f.isCancelled());
159 jsr166 1.14 assertTrue(f.toString().contains("[Completed exceptionally]"));
160 dl 1.5 }
161    
162     void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
163     try {
164 jsr166 1.20 f.get(LONG_DELAY_MS, MILLISECONDS);
165     shouldThrow();
166     } catch (ExecutionException success) {
167     assertTrue(success.getCause() instanceof CancellationException);
168     } catch (Throwable fail) { threadUnexpectedException(fail); }
169     try {
170 dl 1.5 f.join();
171     shouldThrow();
172 jsr166 1.8 } catch (CompletionException success) {
173     assertTrue(success.getCause() instanceof CancellationException);
174 dl 1.5 }
175     try {
176     f.getNow(null);
177     shouldThrow();
178 jsr166 1.8 } catch (CompletionException success) {
179     assertTrue(success.getCause() instanceof CancellationException);
180 dl 1.5 }
181     try {
182     f.get();
183     shouldThrow();
184 jsr166 1.8 } catch (ExecutionException success) {
185     assertTrue(success.getCause() instanceof CancellationException);
186     } catch (Throwable fail) { threadUnexpectedException(fail); }
187 dl 1.5 assertTrue(f.isDone());
188     assertFalse(f.isCancelled());
189 dl 1.26 assertTrue(f.isCompletedExceptionally());
190 jsr166 1.14 assertTrue(f.toString().contains("[Completed exceptionally]"));
191 dl 1.5 }
192    
193     /**
194     * A newly constructed CompletableFuture is incomplete, as indicated
195     * by methods isDone, isCancelled, and getNow
196     */
197     public void testConstructor() {
198 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
199 dl 1.5 checkIncomplete(f);
200     }
201    
202     /**
203     * complete completes normally, as indicated by methods isDone,
204     * isCancelled, join, get, and getNow
205     */
206     public void testComplete() {
207 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
208 dl 1.5 checkIncomplete(f);
209     f.complete(one);
210     checkCompletedNormally(f, one);
211     }
212    
213     /**
214     * completeExceptionally completes exceptionally, as indicated by
215     * methods isDone, isCancelled, join, get, and getNow
216     */
217     public void testCompleteExceptionally() {
218 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
219 dl 1.5 checkIncomplete(f);
220     f.completeExceptionally(new CFException());
221     checkCompletedWithWrappedCFException(f);
222     }
223    
224     /**
225     * cancel completes exceptionally and reports cancelled, as indicated by
226     * methods isDone, isCancelled, join, get, and getNow
227     */
228     public void testCancel() {
229 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
230 dl 1.5 checkIncomplete(f);
231     assertTrue(f.cancel(true));
232     checkCancelled(f);
233     }
234    
235     /**
236     * obtrudeValue forces completion with given value
237     */
238     public void testObtrudeValue() {
239 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
240 dl 1.5 checkIncomplete(f);
241     f.complete(one);
242     checkCompletedNormally(f, one);
243     f.obtrudeValue(three);
244     checkCompletedNormally(f, three);
245     f.obtrudeValue(two);
246     checkCompletedNormally(f, two);
247 jsr166 1.22 f = new CompletableFuture<>();
248 dl 1.5 f.obtrudeValue(three);
249     checkCompletedNormally(f, three);
250 jsr166 1.22 f = new CompletableFuture<>();
251 dl 1.5 f.completeExceptionally(new CFException());
252     f.obtrudeValue(four);
253     checkCompletedNormally(f, four);
254 jsr166 1.4 }
255    
256 dl 1.5 /**
257     * obtrudeException forces completion with given exception
258     */
259     public void testObtrudeException() {
260 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
261 dl 1.5 checkIncomplete(f);
262     f.complete(one);
263     checkCompletedNormally(f, one);
264     f.obtrudeException(new CFException());
265     checkCompletedWithWrappedCFException(f);
266 jsr166 1.22 f = new CompletableFuture<>();
267 dl 1.5 f.obtrudeException(new CFException());
268     checkCompletedWithWrappedCFException(f);
269 jsr166 1.22 f = new CompletableFuture<>();
270 dl 1.5 f.completeExceptionally(new CFException());
271     f.obtrudeValue(four);
272     checkCompletedNormally(f, four);
273     f.obtrudeException(new CFException());
274     checkCompletedWithWrappedCFException(f);
275     }
276 jsr166 1.6
277 dl 1.5 /**
278     * getNumberOfDependents returns number of dependent tasks
279     */
280     public void testGetNumberOfDependents() {
281 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
282 dl 1.5 assertEquals(f.getNumberOfDependents(), 0);
283     CompletableFuture g = f.thenRun(new Noop());
284     assertEquals(f.getNumberOfDependents(), 1);
285     assertEquals(g.getNumberOfDependents(), 0);
286     CompletableFuture h = f.thenRun(new Noop());
287     assertEquals(f.getNumberOfDependents(), 2);
288     f.complete(1);
289     checkCompletedNormally(g, null);
290     assertEquals(f.getNumberOfDependents(), 0);
291     assertEquals(g.getNumberOfDependents(), 0);
292 jsr166 1.3 }
293    
294 dl 1.5 /**
295     * toString indicates current completion state
296     */
297 jsr166 1.1 public void testToString() {
298     CompletableFuture<String> f;
299 jsr166 1.2
300 jsr166 1.1 f = new CompletableFuture<String>();
301 jsr166 1.2 assertTrue(f.toString().contains("[Not completed]"));
302    
303 jsr166 1.1 f.complete("foo");
304     assertTrue(f.toString().contains("[Completed normally]"));
305 jsr166 1.2
306 jsr166 1.1 f = new CompletableFuture<String>();
307     f.completeExceptionally(new IndexOutOfBoundsException());
308     assertTrue(f.toString().contains("[Completed exceptionally]"));
309     }
310 jsr166 1.4
311 dl 1.9 /**
312 jsr166 1.10 * completedFuture returns a completed CompletableFuture with given value
313 dl 1.9 */
314     public void testCompletedFuture() {
315     CompletableFuture<String> f = CompletableFuture.completedFuture("test");
316     checkCompletedNormally(f, "test");
317     }
318    
319 jsr166 1.18 // Choose non-commutative actions for better coverage
320    
321 jsr166 1.36 // A non-commutative function that handles null values as well
322     public static int subtract(Integer x, Integer y) {
323     return ((x == null) ? 42 : x.intValue())
324     - ((y == null) ? 99 : y.intValue());
325     }
326    
327 jsr166 1.6 static final Supplier<Integer> supplyOne =
328 dl 1.5 () -> Integer.valueOf(1);
329 jsr166 1.6 static final Function<Integer, Integer> inc =
330 dl 1.5 (Integer x) -> Integer.valueOf(x.intValue() + 1);
331 jsr166 1.18 static final BiFunction<Integer, Integer, Integer> subtract =
332 jsr166 1.36 (Integer x, Integer y) -> subtract(x, y);
333 dl 1.5 static final class IncAction implements Consumer<Integer> {
334     int value;
335     public void accept(Integer x) { value = x.intValue() + 1; }
336     }
337 jsr166 1.22 static final class SubtractAction implements BiConsumer<Integer, Integer> {
338 jsr166 1.36 volatile int invocationCount = 0;
339 dl 1.5 int value;
340 jsr166 1.36 // Check this action was invoked exactly once when result is computed.
341     public boolean ran() { return invocationCount == 1; }
342 jsr166 1.6 public void accept(Integer x, Integer y) {
343 jsr166 1.36 invocationCount++;
344 jsr166 1.35 value = subtract(x, y);
345 dl 1.5 }
346     }
347 jsr166 1.36 static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
348     volatile int invocationCount = 0;
349     int value;
350     // Check this action was invoked exactly once when result is computed.
351     public boolean ran() { return invocationCount == 1; }
352     public Integer apply(Integer x, Integer y) {
353     invocationCount++;
354     return subtract(x, y);
355     }
356     }
357 dl 1.5 static final class Noop implements Runnable {
358     boolean ran;
359     public void run() { ran = true; }
360     }
361    
362     static final class FailingSupplier implements Supplier<Integer> {
363     boolean ran;
364     public Integer get() { ran = true; throw new CFException(); }
365     }
366     static final class FailingConsumer implements Consumer<Integer> {
367     boolean ran;
368     public void accept(Integer x) { ran = true; throw new CFException(); }
369     }
370     static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
371     boolean ran;
372     public void accept(Integer x, Integer y) { ran = true; throw new CFException(); }
373     }
374     static final class FailingFunction implements Function<Integer, Integer> {
375     boolean ran;
376     public Integer apply(Integer x) { ran = true; throw new CFException(); }
377     }
378     static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
379     boolean ran;
380     public Integer apply(Integer x, Integer y) { ran = true; throw new CFException(); }
381     }
382     static final class FailingNoop implements Runnable {
383     boolean ran;
384     public void run() { ran = true; throw new CFException(); }
385     }
386    
387 jsr166 1.18 static final class CompletableFutureInc
388     implements Function<Integer, CompletableFuture<Integer>> {
389 jsr166 1.20 boolean ran;
390 dl 1.5 public CompletableFuture<Integer> apply(Integer x) {
391 jsr166 1.20 ran = true;
392 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
393 dl 1.5 f.complete(Integer.valueOf(x.intValue() + 1));
394     return f;
395     }
396     }
397    
398 jsr166 1.18 static final class FailingCompletableFutureFunction
399     implements Function<Integer, CompletableFuture<Integer>> {
400 dl 1.5 boolean ran;
401     public CompletableFuture<Integer> apply(Integer x) {
402     ran = true; throw new CFException();
403     }
404     }
405 jsr166 1.6
406 dl 1.5 // Used for explicit executor tests
407     static final class ThreadExecutor implements Executor {
408 jsr166 1.17 AtomicInteger count = new AtomicInteger(0);
409    
410 dl 1.5 public void execute(Runnable r) {
411 jsr166 1.17 count.getAndIncrement();
412 dl 1.5 new Thread(r).start();
413     }
414     }
415    
416     static final class ExceptionToInteger implements Function<Throwable, Integer> {
417     public Integer apply(Throwable x) { return Integer.valueOf(3); }
418     }
419    
420     static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
421 jsr166 1.15 boolean ran;
422 jsr166 1.6 public Integer apply(Integer x, Throwable t) {
423 jsr166 1.15 ran = true;
424 dl 1.5 return (t == null) ? two : three;
425     }
426     }
427    
428     /**
429 jsr166 1.35 * Permits the testing of parallel code for the 3 different
430     * execution modes without repeating all the testing code.
431     */
432     enum ExecutionMode {
433     DEFAULT {
434     public <T,U> CompletableFuture<Void> runAfterBoth
435     (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
436     return f.runAfterBoth(g, a);
437     }
438     public <T,U> CompletableFuture<Void> thenAcceptBoth
439     (CompletableFuture<T> f,
440     CompletionStage<? extends U> g,
441     BiConsumer<? super T,? super U> a) {
442     return f.thenAcceptBoth(g, a);
443     }
444 jsr166 1.36 public <T,U,V> CompletableFuture<V> thenCombine
445     (CompletableFuture<T> f,
446     CompletionStage<? extends U> g,
447     BiFunction<? super T,? super U,? extends V> a) {
448     return f.thenCombine(g, a);
449     }
450 jsr166 1.35 },
451    
452     // /** Experimental way to do more testing */
453     // REVERSE_DEFAULT {
454     // public <T,U> CompletableFuture<Void> runAfterBoth
455     // (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
456     // return g.runAfterBoth(f, a);
457     // }
458     // public <T,U> CompletableFuture<Void> thenAcceptBoth
459     // (CompletableFuture<T> f,
460     // CompletionStage<? extends U> g,
461     // BiConsumer<? super T,? super U> a) {
462     // return DEFAULT.thenAcceptBoth(f, g, a);
463     // }
464     // },
465    
466     DEFAULT_ASYNC {
467     public <T,U> CompletableFuture<Void> runAfterBoth
468     (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
469     return f.runAfterBothAsync(g, a);
470     }
471     public <T,U> CompletableFuture<Void> thenAcceptBoth
472     (CompletableFuture<T> f,
473     CompletionStage<? extends U> g,
474     BiConsumer<? super T,? super U> a) {
475     return f.thenAcceptBothAsync(g, a);
476     }
477 jsr166 1.36 public <T,U,V> CompletableFuture<V> thenCombine
478     (CompletableFuture<T> f,
479     CompletionStage<? extends U> g,
480     BiFunction<? super T,? super U,? extends V> a) {
481     return f.thenCombineAsync(g, a);
482     }
483 jsr166 1.35 },
484    
485     // REVERSE_DEFAULT_ASYNC {
486     // public <T,U> CompletableFuture<Void> runAfterBoth
487     // (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
488     // return f.runAfterBothAsync(g, a);
489     // }
490     // public <T,U> CompletableFuture<Void> thenAcceptBoth
491     // (CompletableFuture<T> f,
492     // CompletionStage<? extends U> g,
493     // BiConsumer<? super T,? super U> a) {
494     // return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
495     // }
496     // },
497    
498     EXECUTOR {
499     public <T,U> CompletableFuture<Void> runAfterBoth
500     (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
501     return f.runAfterBothAsync(g, a, new ThreadExecutor());
502     }
503     public <T,U> CompletableFuture<Void> thenAcceptBoth
504     (CompletableFuture<T> f,
505     CompletionStage<? extends U> g,
506     BiConsumer<? super T,? super U> a) {
507     return f.thenAcceptBothAsync(g, a, new ThreadExecutor());
508     }
509 jsr166 1.36 public <T,U,V> CompletableFuture<V> thenCombine
510     (CompletableFuture<T> f,
511     CompletionStage<? extends U> g,
512     BiFunction<? super T,? super U,? extends V> a) {
513     return f.thenCombineAsync(g, a, new ThreadExecutor());
514     }
515 jsr166 1.35 };
516    
517     public abstract <T,U> CompletableFuture<Void> runAfterBoth
518     (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
519     public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
520     (CompletableFuture<T> f,
521     CompletionStage<? extends U> g,
522     BiConsumer<? super T,? super U> a);
523 jsr166 1.36 public abstract <T,U,V> CompletableFuture<V> thenCombine
524     (CompletableFuture<T> f,
525     CompletionStage<? extends U> g,
526     BiFunction<? super T,? super U,? extends V> a);
527 jsr166 1.35 }
528    
529     /**
530 dl 1.5 * exceptionally action completes with function value on source
531 jsr166 1.30 * exception; otherwise with source value
532 dl 1.5 */
533     public void testExceptionally() {
534 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
535 dl 1.5 ExceptionToInteger r = new ExceptionToInteger();
536     CompletableFuture<Integer> g = f.exceptionally(r);
537     f.completeExceptionally(new CFException());
538     checkCompletedNormally(g, three);
539    
540 jsr166 1.22 f = new CompletableFuture<>();
541 dl 1.5 r = new ExceptionToInteger();
542     g = f.exceptionally(r);
543     f.complete(one);
544     checkCompletedNormally(g, one);
545     }
546    
547     /**
548     * handle action completes normally with function value on either
549     * normal or exceptional completion of source
550     */
551     public void testHandle() {
552 jsr166 1.15 CompletableFuture<Integer> f, g;
553     IntegerHandler r;
554    
555 jsr166 1.22 f = new CompletableFuture<>();
556 dl 1.5 f.completeExceptionally(new CFException());
557 jsr166 1.15 g = f.handle(r = new IntegerHandler());
558     assertTrue(r.ran);
559 dl 1.5 checkCompletedNormally(g, three);
560    
561 jsr166 1.22 f = new CompletableFuture<>();
562 jsr166 1.15 g = f.handle(r = new IntegerHandler());
563     assertFalse(r.ran);
564     f.completeExceptionally(new CFException());
565     checkCompletedNormally(g, three);
566     assertTrue(r.ran);
567    
568 jsr166 1.22 f = new CompletableFuture<>();
569 dl 1.5 f.complete(one);
570 jsr166 1.15 g = f.handle(r = new IntegerHandler());
571     assertTrue(r.ran);
572     checkCompletedNormally(g, two);
573    
574 jsr166 1.22 f = new CompletableFuture<>();
575 jsr166 1.15 g = f.handle(r = new IntegerHandler());
576     assertFalse(r.ran);
577     f.complete(one);
578     assertTrue(r.ran);
579 dl 1.5 checkCompletedNormally(g, two);
580     }
581    
582     /**
583     * runAsync completes after running Runnable
584     */
585     public void testRunAsync() {
586     Noop r = new Noop();
587     CompletableFuture<Void> f = CompletableFuture.runAsync(r);
588     assertNull(f.join());
589     assertTrue(r.ran);
590 jsr166 1.14 checkCompletedNormally(f, null);
591 dl 1.5 }
592    
593     /**
594     * runAsync with executor completes after running Runnable
595     */
596     public void testRunAsync2() {
597     Noop r = new Noop();
598 jsr166 1.17 ThreadExecutor exec = new ThreadExecutor();
599     CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
600 dl 1.5 assertNull(f.join());
601     assertTrue(r.ran);
602 jsr166 1.14 checkCompletedNormally(f, null);
603 jsr166 1.17 assertEquals(1, exec.count.get());
604 dl 1.5 }
605    
606     /**
607     * failing runAsync completes exceptionally after running Runnable
608     */
609     public void testRunAsync3() {
610     FailingNoop r = new FailingNoop();
611     CompletableFuture<Void> f = CompletableFuture.runAsync(r);
612     checkCompletedWithWrappedCFException(f);
613     assertTrue(r.ran);
614     }
615    
616     /**
617     * supplyAsync completes with result of supplier
618     */
619     public void testSupplyAsync() {
620 jsr166 1.17 CompletableFuture<Integer> f;
621     f = CompletableFuture.supplyAsync(supplyOne);
622 dl 1.5 assertEquals(f.join(), one);
623 jsr166 1.17 checkCompletedNormally(f, one);
624 dl 1.5 }
625    
626     /**
627     * supplyAsync with executor completes with result of supplier
628     */
629     public void testSupplyAsync2() {
630 jsr166 1.17 CompletableFuture<Integer> f;
631     f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
632 dl 1.5 assertEquals(f.join(), one);
633 jsr166 1.17 checkCompletedNormally(f, one);
634 dl 1.5 }
635    
636     /**
637     * Failing supplyAsync completes exceptionally
638     */
639     public void testSupplyAsync3() {
640     FailingSupplier r = new FailingSupplier();
641     CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
642     checkCompletedWithWrappedCFException(f);
643     assertTrue(r.ran);
644     }
645    
646 jsr166 1.7 // seq completion methods
647 jsr166 1.6
648 dl 1.5 /**
649     * thenRun result completes normally after normal completion of source
650     */
651     public void testThenRun() {
652 jsr166 1.23 CompletableFuture<Integer> f;
653     CompletableFuture<Void> g;
654     Noop r;
655    
656     f = new CompletableFuture<>();
657     g = f.thenRun(r = new Noop());
658 dl 1.5 f.complete(null);
659     checkCompletedNormally(g, null);
660 jsr166 1.23 assertTrue(r.ran);
661    
662 jsr166 1.22 f = new CompletableFuture<>();
663 dl 1.5 f.complete(null);
664 jsr166 1.23 g = f.thenRun(r = new Noop());
665 dl 1.5 checkCompletedNormally(g, null);
666 jsr166 1.23 assertTrue(r.ran);
667 dl 1.5 }
668    
669     /**
670     * thenRun result completes exceptionally after exceptional
671     * completion of source
672     */
673     public void testThenRun2() {
674 jsr166 1.23 CompletableFuture<Integer> f;
675     CompletableFuture<Void> g;
676     Noop r;
677    
678     f = new CompletableFuture<>();
679     g = f.thenRun(r = new Noop());
680     f.completeExceptionally(new CFException());
681     checkCompletedWithWrappedCFException(g);
682     assertFalse(r.ran);
683    
684     f = new CompletableFuture<>();
685 dl 1.5 f.completeExceptionally(new CFException());
686 jsr166 1.23 g = f.thenRun(r = new Noop());
687 dl 1.5 checkCompletedWithWrappedCFException(g);
688 jsr166 1.23 assertFalse(r.ran);
689 dl 1.5 }
690    
691     /**
692     * thenRun result completes exceptionally if action does
693     */
694     public void testThenRun3() {
695 jsr166 1.23 CompletableFuture<Integer> f;
696     CompletableFuture<Void> g;
697     FailingNoop r;
698    
699     f = new CompletableFuture<>();
700     g = f.thenRun(r = new FailingNoop());
701     f.complete(null);
702     checkCompletedWithWrappedCFException(g);
703    
704     f = new CompletableFuture<>();
705 dl 1.5 f.complete(null);
706 jsr166 1.23 g = f.thenRun(r = new FailingNoop());
707 dl 1.5 checkCompletedWithWrappedCFException(g);
708     }
709    
710     /**
711     * thenRun result completes exceptionally if source cancelled
712     */
713     public void testThenRun4() {
714 jsr166 1.23 CompletableFuture<Integer> f;
715     CompletableFuture<Void> g;
716     Noop r;
717    
718     f = new CompletableFuture<>();
719     g = f.thenRun(r = new Noop());
720     assertTrue(f.cancel(true));
721     checkCompletedWithWrappedCancellationException(g);
722    
723     f = new CompletableFuture<>();
724 dl 1.5 assertTrue(f.cancel(true));
725 jsr166 1.23 g = f.thenRun(r = new Noop());
726 dl 1.5 checkCompletedWithWrappedCancellationException(g);
727     }
728    
729     /**
730     * thenApply result completes normally after normal completion of source
731     */
732     public void testThenApply() {
733 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
734 dl 1.5 CompletableFuture<Integer> g = f.thenApply(inc);
735     f.complete(one);
736     checkCompletedNormally(g, two);
737     }
738    
739     /**
740     * thenApply result completes exceptionally after exceptional
741     * completion of source
742     */
743     public void testThenApply2() {
744 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
745 dl 1.5 CompletableFuture<Integer> g = f.thenApply(inc);
746     f.completeExceptionally(new CFException());
747     checkCompletedWithWrappedCFException(g);
748     }
749    
750     /**
751     * thenApply result completes exceptionally if action does
752     */
753     public void testThenApply3() {
754 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
755 dl 1.5 CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
756     f.complete(one);
757     checkCompletedWithWrappedCFException(g);
758     }
759    
760     /**
761     * thenApply result completes exceptionally if source cancelled
762     */
763     public void testThenApply4() {
764 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
765 dl 1.5 CompletableFuture<Integer> g = f.thenApply(inc);
766     assertTrue(f.cancel(true));
767     checkCompletedWithWrappedCancellationException(g);
768     }
769    
770     /**
771     * thenAccept result completes normally after normal completion of source
772     */
773     public void testThenAccept() {
774 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
775 dl 1.5 IncAction r = new IncAction();
776     CompletableFuture<Void> g = f.thenAccept(r);
777     f.complete(one);
778     checkCompletedNormally(g, null);
779     assertEquals(r.value, 2);
780     }
781    
782     /**
783     * thenAccept result completes exceptionally after exceptional
784     * completion of source
785     */
786     public void testThenAccept2() {
787 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
788 dl 1.5 IncAction r = new IncAction();
789     CompletableFuture<Void> g = f.thenAccept(r);
790     f.completeExceptionally(new CFException());
791     checkCompletedWithWrappedCFException(g);
792     }
793    
794     /**
795     * thenAccept result completes exceptionally if action does
796     */
797     public void testThenAccept3() {
798 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
799 dl 1.5 FailingConsumer r = new FailingConsumer();
800     CompletableFuture<Void> g = f.thenAccept(r);
801     f.complete(one);
802     checkCompletedWithWrappedCFException(g);
803     assertTrue(r.ran);
804     }
805    
806     /**
807     * thenAccept result completes exceptionally if source cancelled
808     */
809     public void testThenAccept4() {
810 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
811 dl 1.5 IncAction r = new IncAction();
812     CompletableFuture<Void> g = f.thenAccept(r);
813     assertTrue(f.cancel(true));
814     checkCompletedWithWrappedCancellationException(g);
815     }
816    
817     /**
818 jsr166 1.18 * thenCombine result completes normally after normal completion
819     * of sources
820 dl 1.5 */
821 jsr166 1.36 public void testThenCombine_normalCompletion1() {
822     for (ExecutionMode m : ExecutionMode.values())
823     for (Integer v1 : new Integer[] { 1, null })
824     for (Integer v2 : new Integer[] { 2, null }) {
825    
826     final CompletableFuture<Integer> f = new CompletableFuture<>();
827     final CompletableFuture<Integer> g = new CompletableFuture<>();
828     final SubtractFunction r = new SubtractFunction();
829     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
830 dl 1.5
831 jsr166 1.36 f.complete(v1);
832 jsr166 1.18 checkIncomplete(h);
833 jsr166 1.36 assertFalse(r.ran());
834     g.complete(v2);
835    
836     checkCompletedNormally(h, subtract(v1, v2));
837     checkCompletedNormally(f, v1);
838     checkCompletedNormally(g, v2);
839     }
840     }
841    
842     public void testThenCombine_normalCompletion2() {
843     for (ExecutionMode m : ExecutionMode.values())
844     for (Integer v1 : new Integer[] { 1, null })
845     for (Integer v2 : new Integer[] { 2, null }) {
846 jsr166 1.18
847 jsr166 1.36 final CompletableFuture<Integer> f = new CompletableFuture<>();
848     final CompletableFuture<Integer> g = new CompletableFuture<>();
849     final SubtractFunction r = new SubtractFunction();
850     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
851    
852     g.complete(v2);
853 jsr166 1.18 checkIncomplete(h);
854 jsr166 1.36 assertFalse(r.ran());
855     f.complete(v1);
856    
857     checkCompletedNormally(h, subtract(v1, v2));
858     checkCompletedNormally(f, v1);
859     checkCompletedNormally(g, v2);
860     }
861     }
862 jsr166 1.18
863 jsr166 1.36 public void testThenCombine_normalCompletion3() {
864     for (ExecutionMode m : ExecutionMode.values())
865     for (Integer v1 : new Integer[] { 1, null })
866     for (Integer v2 : new Integer[] { 2, null }) {
867    
868     final CompletableFuture<Integer> f = new CompletableFuture<>();
869     final CompletableFuture<Integer> g = new CompletableFuture<>();
870     final SubtractFunction r = new SubtractFunction();
871    
872     g.complete(v2);
873     f.complete(v1);
874     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
875    
876     checkCompletedNormally(h, subtract(v1, v2));
877     checkCompletedNormally(f, v1);
878     checkCompletedNormally(g, v2);
879     }
880     }
881    
882     public void testThenCombine_normalCompletion4() {
883     for (ExecutionMode m : ExecutionMode.values())
884     for (Integer v1 : new Integer[] { 1, null })
885     for (Integer v2 : new Integer[] { 2, null }) {
886    
887     final CompletableFuture<Integer> f = new CompletableFuture<>();
888     final CompletableFuture<Integer> g = new CompletableFuture<>();
889     final SubtractFunction r = new SubtractFunction();
890    
891     f.complete(v1);
892     g.complete(v2);
893     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
894    
895     checkCompletedNormally(h, subtract(v1, v2));
896     checkCompletedNormally(f, v1);
897     checkCompletedNormally(g, v2);
898     }
899 dl 1.5 }
900    
901     /**
902     * thenCombine result completes exceptionally after exceptional
903     * completion of either source
904     */
905 jsr166 1.36 public void testThenCombine_exceptionalCompletion1() {
906     for (ExecutionMode m : ExecutionMode.values())
907     for (Integer v1 : new Integer[] { 1, null }) {
908    
909     final CompletableFuture<Integer> f = new CompletableFuture<>();
910     final CompletableFuture<Integer> g = new CompletableFuture<>();
911     final SubtractFunction r = new SubtractFunction();
912     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
913     final CFException ex = new CFException();
914 jsr166 1.18
915 jsr166 1.36 f.completeExceptionally(ex);
916 jsr166 1.18 checkIncomplete(h);
917 jsr166 1.36 g.complete(v1);
918    
919     checkCompletedWithWrappedCFException(h, ex);
920     checkCompletedWithWrappedCFException(f, ex);
921     assertFalse(r.ran());
922     checkCompletedNormally(g, v1);
923     }
924     }
925    
926     public void testThenCombine_exceptionalCompletion2() {
927     for (ExecutionMode m : ExecutionMode.values())
928     for (Integer v1 : new Integer[] { 1, null }) {
929    
930     final CompletableFuture<Integer> f = new CompletableFuture<>();
931     final CompletableFuture<Integer> g = new CompletableFuture<>();
932     final SubtractFunction r = new SubtractFunction();
933     final CompletableFuture<Integer> h = m.thenCombine(f, g, subtract);
934     final CFException ex = new CFException();
935 jsr166 1.18
936 jsr166 1.36 g.completeExceptionally(ex);
937 jsr166 1.18 checkIncomplete(h);
938 jsr166 1.36 f.complete(v1);
939    
940     checkCompletedWithWrappedCFException(h, ex);
941     checkCompletedWithWrappedCFException(g, ex);
942     assertFalse(r.ran());
943     checkCompletedNormally(f, v1);
944     }
945     }
946    
947     public void testThenCombine_exceptionalCompletion3() {
948     for (ExecutionMode m : ExecutionMode.values())
949     for (Integer v1 : new Integer[] { 1, null }) {
950    
951     final CompletableFuture<Integer> f = new CompletableFuture<>();
952     final CompletableFuture<Integer> g = new CompletableFuture<>();
953     final SubtractFunction r = new SubtractFunction();
954     final CFException ex = new CFException();
955    
956     g.completeExceptionally(ex);
957     f.complete(v1);
958     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
959    
960     checkCompletedWithWrappedCFException(h, ex);
961     checkCompletedWithWrappedCFException(g, ex);
962     assertFalse(r.ran());
963     checkCompletedNormally(f, v1);
964     }
965     }
966    
967     public void testThenCombine_exceptionalCompletion4() {
968     for (ExecutionMode m : ExecutionMode.values())
969     for (Integer v1 : new Integer[] { 1, null }) {
970    
971     final CompletableFuture<Integer> f = new CompletableFuture<>();
972     final CompletableFuture<Integer> g = new CompletableFuture<>();
973     final SubtractFunction r = new SubtractFunction();
974     final CFException ex = new CFException();
975 jsr166 1.18
976 jsr166 1.36 f.completeExceptionally(ex);
977     g.complete(v1);
978     final CompletableFuture<Integer> h = m.thenCombine(f, g, subtract);
979 dl 1.5
980 jsr166 1.36 checkCompletedWithWrappedCFException(h, ex);
981     checkCompletedWithWrappedCFException(f, ex);
982     assertFalse(r.ran());
983     checkCompletedNormally(g, v1);
984     }
985 dl 1.5 }
986    
987     /**
988     * thenCombine result completes exceptionally if action does
989     */
990 jsr166 1.36 public void testThenCombine_actionFailed1() {
991     for (ExecutionMode m : ExecutionMode.values())
992     for (Integer v1 : new Integer[] { 1, null })
993     for (Integer v2 : new Integer[] { 2, null }) {
994    
995     final CompletableFuture<Integer> f = new CompletableFuture<>();
996     final CompletableFuture<Integer> g = new CompletableFuture<>();
997     final FailingBiFunction r = new FailingBiFunction();
998     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
999    
1000     f.complete(v1);
1001     checkIncomplete(h);
1002     g.complete(v2);
1003    
1004     checkCompletedWithWrappedCFException(h);
1005     checkCompletedNormally(f, v1);
1006     checkCompletedNormally(g, v2);
1007     }
1008     }
1009    
1010     public void testThenCombine_actionFailed2() {
1011     for (ExecutionMode m : ExecutionMode.values())
1012     for (Integer v1 : new Integer[] { 1, null })
1013     for (Integer v2 : new Integer[] { 2, null }) {
1014    
1015     final CompletableFuture<Integer> f = new CompletableFuture<>();
1016     final CompletableFuture<Integer> g = new CompletableFuture<>();
1017     final FailingBiFunction r = new FailingBiFunction();
1018     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1019    
1020     g.complete(v2);
1021     checkIncomplete(h);
1022     f.complete(v1);
1023    
1024     checkCompletedWithWrappedCFException(h);
1025     checkCompletedNormally(f, v1);
1026     checkCompletedNormally(g, v2);
1027     }
1028 dl 1.5 }
1029    
1030     /**
1031     * thenCombine result completes exceptionally if either source cancelled
1032     */
1033 jsr166 1.36 public void testThenCombine_sourceCancelled1() {
1034     for (ExecutionMode m : ExecutionMode.values())
1035     for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1036     for (Integer v1 : new Integer[] { 1, null }) {
1037    
1038     final CompletableFuture<Integer> f = new CompletableFuture<>();
1039     final CompletableFuture<Integer> g = new CompletableFuture<>();
1040     final SubtractFunction r = new SubtractFunction();
1041     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1042 jsr166 1.18
1043 jsr166 1.36 assertTrue(f.cancel(mayInterruptIfRunning));
1044 jsr166 1.18 checkIncomplete(h);
1045 jsr166 1.36 g.complete(v1);
1046    
1047 jsr166 1.18 checkCompletedWithWrappedCancellationException(h);
1048 jsr166 1.36 checkCancelled(f);
1049     assertFalse(r.ran());
1050     checkCompletedNormally(g, v1);
1051     }
1052     }
1053    
1054     public void testThenCombine_sourceCancelled2() {
1055     for (ExecutionMode m : ExecutionMode.values())
1056     for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1057     for (Integer v1 : new Integer[] { 1, null }) {
1058 jsr166 1.18
1059 jsr166 1.36 final CompletableFuture<Integer> f = new CompletableFuture<>();
1060     final CompletableFuture<Integer> g = new CompletableFuture<>();
1061     final SubtractFunction r = new SubtractFunction();
1062     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1063    
1064     assertTrue(g.cancel(mayInterruptIfRunning));
1065 jsr166 1.18 checkIncomplete(h);
1066 jsr166 1.36 f.complete(v1);
1067    
1068     checkCompletedWithWrappedCancellationException(h);
1069     checkCancelled(g);
1070     assertFalse(r.ran());
1071     checkCompletedNormally(f, v1);
1072     }
1073     }
1074    
1075     public void testThenCombine_sourceCancelled3() {
1076     for (ExecutionMode m : ExecutionMode.values())
1077     for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1078     for (Integer v1 : new Integer[] { 1, null }) {
1079    
1080     final CompletableFuture<Integer> f = new CompletableFuture<>();
1081     final CompletableFuture<Integer> g = new CompletableFuture<>();
1082     final SubtractFunction r = new SubtractFunction();
1083    
1084     assertTrue(g.cancel(mayInterruptIfRunning));
1085     f.complete(v1);
1086     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1087    
1088 jsr166 1.18 checkCompletedWithWrappedCancellationException(h);
1089 jsr166 1.36 checkCancelled(g);
1090     assertFalse(r.ran());
1091     checkCompletedNormally(f, v1);
1092     }
1093     }
1094    
1095     public void testThenCombine_sourceCancelled4() {
1096     for (ExecutionMode m : ExecutionMode.values())
1097     for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1098     for (Integer v1 : new Integer[] { 1, null }) {
1099    
1100     final CompletableFuture<Integer> f = new CompletableFuture<>();
1101     final CompletableFuture<Integer> g = new CompletableFuture<>();
1102     final SubtractFunction r = new SubtractFunction();
1103    
1104     assertTrue(f.cancel(mayInterruptIfRunning));
1105     g.complete(v1);
1106     final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1107 jsr166 1.18
1108     checkCompletedWithWrappedCancellationException(h);
1109 jsr166 1.36 checkCancelled(f);
1110     assertFalse(r.ran());
1111     checkCompletedNormally(g, v1);
1112     }
1113 dl 1.5 }
1114    
1115     /**
1116     * thenAcceptBoth result completes normally after normal
1117     * completion of sources
1118     */
1119 jsr166 1.35 public void testThenAcceptBoth_normalCompletion1() {
1120     for (ExecutionMode m : ExecutionMode.values())
1121     for (Integer v1 : new Integer[] { 1, null })
1122     for (Integer v2 : new Integer[] { 2, null }) {
1123    
1124     final CompletableFuture<Integer> f = new CompletableFuture<>();
1125     final CompletableFuture<Integer> g = new CompletableFuture<>();
1126     final SubtractAction r = new SubtractAction();
1127     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1128 jsr166 1.22
1129 jsr166 1.35 f.complete(v1);
1130 jsr166 1.22 checkIncomplete(h);
1131 jsr166 1.35 assertEquals(r.value, 0);
1132     g.complete(v2);
1133    
1134 jsr166 1.22 checkCompletedNormally(h, null);
1135 jsr166 1.36 assertEquals(r.value, subtract(v1, v2));
1136 jsr166 1.35 checkCompletedNormally(f, v1);
1137     checkCompletedNormally(g, v2);
1138     }
1139     }
1140    
1141     public void testThenAcceptBoth_normalCompletion2() {
1142     for (ExecutionMode m : ExecutionMode.values())
1143     for (Integer v1 : new Integer[] { 1, null })
1144     for (Integer v2 : new Integer[] { 2, null }) {
1145    
1146     final CompletableFuture<Integer> f = new CompletableFuture<>();
1147     final CompletableFuture<Integer> g = new CompletableFuture<>();
1148     final SubtractAction r = new SubtractAction();
1149     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1150 jsr166 1.22
1151 jsr166 1.35 g.complete(v2);
1152 jsr166 1.22 checkIncomplete(h);
1153 jsr166 1.35 assertEquals(r.value, 0);
1154     f.complete(v1);
1155    
1156     checkCompletedNormally(h, null);
1157 jsr166 1.36 assertEquals(r.value, subtract(v1, v2));
1158 jsr166 1.35 checkCompletedNormally(f, v1);
1159     checkCompletedNormally(g, v2);
1160     }
1161     }
1162    
1163     public void testThenAcceptBoth_normalCompletion3() {
1164     for (ExecutionMode m : ExecutionMode.values())
1165     for (Integer v1 : new Integer[] { 1, null })
1166     for (Integer v2 : new Integer[] { 2, null }) {
1167    
1168     final CompletableFuture<Integer> f = new CompletableFuture<>();
1169     final CompletableFuture<Integer> g = new CompletableFuture<>();
1170     final SubtractAction r = new SubtractAction();
1171    
1172     g.complete(v2);
1173     f.complete(v1);
1174     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1175    
1176 jsr166 1.22 checkCompletedNormally(h, null);
1177 jsr166 1.36 assertEquals(r.value, subtract(v1, v2));
1178 jsr166 1.35 checkCompletedNormally(f, v1);
1179     checkCompletedNormally(g, v2);
1180     }
1181     }
1182    
1183     public void testThenAcceptBoth_normalCompletion4() {
1184     for (ExecutionMode m : ExecutionMode.values())
1185     for (Integer v1 : new Integer[] { 1, null })
1186     for (Integer v2 : new Integer[] { 2, null }) {
1187    
1188     final CompletableFuture<Integer> f = new CompletableFuture<>();
1189     final CompletableFuture<Integer> g = new CompletableFuture<>();
1190     final SubtractAction r = new SubtractAction();
1191    
1192     f.complete(v1);
1193     g.complete(v2);
1194     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1195 dl 1.5
1196 jsr166 1.22 checkCompletedNormally(h, null);
1197 jsr166 1.36 assertEquals(r.value, subtract(v1, v2));
1198 jsr166 1.35 checkCompletedNormally(f, v1);
1199     checkCompletedNormally(g, v2);
1200     }
1201 dl 1.5 }
1202    
1203     /**
1204     * thenAcceptBoth result completes exceptionally after exceptional
1205     * completion of either source
1206     */
1207 jsr166 1.35 public void testThenAcceptBoth_exceptionalCompletion1() {
1208     for (ExecutionMode m : ExecutionMode.values())
1209     for (Integer v1 : new Integer[] { 1, null }) {
1210    
1211     final CompletableFuture<Integer> f = new CompletableFuture<>();
1212     final CompletableFuture<Integer> g = new CompletableFuture<>();
1213     final SubtractAction r = new SubtractAction();
1214     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1215     final CFException ex = new CFException();
1216 jsr166 1.22
1217 jsr166 1.35 f.completeExceptionally(ex);
1218 jsr166 1.22 checkIncomplete(h);
1219 jsr166 1.35 g.complete(v1);
1220    
1221     checkCompletedWithWrappedCFException(h, ex);
1222     checkCompletedWithWrappedCFException(f, ex);
1223     assertFalse(r.ran());
1224     checkCompletedNormally(g, v1);
1225     }
1226     }
1227    
1228     public void testThenAcceptBoth_exceptionalCompletion2() {
1229     for (ExecutionMode m : ExecutionMode.values())
1230     for (Integer v1 : new Integer[] { 1, null }) {
1231    
1232     final CompletableFuture<Integer> f = new CompletableFuture<>();
1233     final CompletableFuture<Integer> g = new CompletableFuture<>();
1234     final SubtractAction r = new SubtractAction();
1235     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1236     final CFException ex = new CFException();
1237 jsr166 1.22
1238 jsr166 1.35 g.completeExceptionally(ex);
1239 jsr166 1.22 checkIncomplete(h);
1240 jsr166 1.35 f.complete(v1);
1241    
1242     checkCompletedWithWrappedCFException(h, ex);
1243     checkCompletedWithWrappedCFException(g, ex);
1244     assertFalse(r.ran());
1245     checkCompletedNormally(f, v1);
1246     }
1247     }
1248    
1249     public void testThenAcceptBoth_exceptionalCompletion3() {
1250     for (ExecutionMode m : ExecutionMode.values())
1251     for (Integer v1 : new Integer[] { 1, null }) {
1252    
1253     final CompletableFuture<Integer> f = new CompletableFuture<>();
1254     final CompletableFuture<Integer> g = new CompletableFuture<>();
1255     final SubtractAction r = new SubtractAction();
1256     final CFException ex = new CFException();
1257    
1258     g.completeExceptionally(ex);
1259     f.complete(v1);
1260     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1261    
1262     checkCompletedWithWrappedCFException(h, ex);
1263     checkCompletedWithWrappedCFException(g, ex);
1264     assertFalse(r.ran());
1265     checkCompletedNormally(f, v1);
1266     }
1267     }
1268    
1269     public void testThenAcceptBoth_exceptionalCompletion4() {
1270     for (ExecutionMode m : ExecutionMode.values())
1271     for (Integer v1 : new Integer[] { 1, null }) {
1272    
1273     final CompletableFuture<Integer> f = new CompletableFuture<>();
1274     final CompletableFuture<Integer> g = new CompletableFuture<>();
1275     final SubtractAction r = new SubtractAction();
1276     final CFException ex = new CFException();
1277 jsr166 1.22
1278 jsr166 1.35 f.completeExceptionally(ex);
1279     g.complete(v1);
1280     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1281 dl 1.5
1282 jsr166 1.35 checkCompletedWithWrappedCFException(h, ex);
1283     checkCompletedWithWrappedCFException(f, ex);
1284     assertFalse(r.ran());
1285     checkCompletedNormally(g, v1);
1286     }
1287 dl 1.5 }
1288    
1289     /**
1290     * thenAcceptBoth result completes exceptionally if action does
1291     */
1292 jsr166 1.35 public void testThenAcceptBoth_actionFailed1() {
1293     for (ExecutionMode m : ExecutionMode.values())
1294     for (Integer v1 : new Integer[] { 1, null })
1295     for (Integer v2 : new Integer[] { 2, null }) {
1296    
1297     final CompletableFuture<Integer> f = new CompletableFuture<>();
1298     final CompletableFuture<Integer> g = new CompletableFuture<>();
1299     final FailingBiConsumer r = new FailingBiConsumer();
1300     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1301 jsr166 1.22
1302 jsr166 1.35 f.complete(v1);
1303 jsr166 1.22 checkIncomplete(h);
1304 jsr166 1.35 g.complete(v2);
1305    
1306 jsr166 1.22 checkCompletedWithWrappedCFException(h);
1307 jsr166 1.35 checkCompletedNormally(f, v1);
1308     checkCompletedNormally(g, v2);
1309     }
1310     }
1311    
1312     public void testThenAcceptBoth_actionFailed2() {
1313     for (ExecutionMode m : ExecutionMode.values())
1314     for (Integer v1 : new Integer[] { 1, null })
1315     for (Integer v2 : new Integer[] { 2, null }) {
1316    
1317     final CompletableFuture<Integer> f = new CompletableFuture<>();
1318     final CompletableFuture<Integer> g = new CompletableFuture<>();
1319     final FailingBiConsumer r = new FailingBiConsumer();
1320     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1321    
1322     g.complete(v2);
1323     checkIncomplete(h);
1324     f.complete(v1);
1325 jsr166 1.22
1326     checkCompletedWithWrappedCFException(h);
1327 jsr166 1.35 checkCompletedNormally(f, v1);
1328     checkCompletedNormally(g, v2);
1329     }
1330 dl 1.5 }
1331    
1332     /**
1333     * thenAcceptBoth result completes exceptionally if either source cancelled
1334     */
1335 jsr166 1.35 public void testThenAcceptBoth_sourceCancelled1() {
1336     for (ExecutionMode m : ExecutionMode.values())
1337     for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1338     for (Integer v1 : new Integer[] { 1, null }) {
1339    
1340     final CompletableFuture<Integer> f = new CompletableFuture<>();
1341     final CompletableFuture<Integer> g = new CompletableFuture<>();
1342     final SubtractAction r = new SubtractAction();
1343     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1344 jsr166 1.22
1345 jsr166 1.35 assertTrue(f.cancel(mayInterruptIfRunning));
1346 jsr166 1.22 checkIncomplete(h);
1347 jsr166 1.35 g.complete(v1);
1348    
1349 jsr166 1.22 checkCompletedWithWrappedCancellationException(h);
1350 jsr166 1.35 checkCancelled(f);
1351     assertFalse(r.ran());
1352     checkCompletedNormally(g, v1);
1353     }
1354     }
1355 jsr166 1.22
1356 jsr166 1.35 public void testThenAcceptBoth_sourceCancelled2() {
1357     for (ExecutionMode m : ExecutionMode.values())
1358     for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1359     for (Integer v1 : new Integer[] { 1, null }) {
1360    
1361     final CompletableFuture<Integer> f = new CompletableFuture<>();
1362     final CompletableFuture<Integer> g = new CompletableFuture<>();
1363     final SubtractAction r = new SubtractAction();
1364     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1365    
1366     assertTrue(g.cancel(mayInterruptIfRunning));
1367 jsr166 1.22 checkIncomplete(h);
1368 jsr166 1.35 f.complete(v1);
1369    
1370 jsr166 1.22 checkCompletedWithWrappedCancellationException(h);
1371 jsr166 1.35 checkCancelled(g);
1372     assertFalse(r.ran());
1373     checkCompletedNormally(f, v1);
1374     }
1375     }
1376    
1377     public void testThenAcceptBoth_sourceCancelled3() {
1378     for (ExecutionMode m : ExecutionMode.values())
1379     for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1380     for (Integer v1 : new Integer[] { 1, null }) {
1381    
1382     final CompletableFuture<Integer> f = new CompletableFuture<>();
1383     final CompletableFuture<Integer> g = new CompletableFuture<>();
1384     final SubtractAction r = new SubtractAction();
1385 jsr166 1.22
1386 jsr166 1.35 assertTrue(g.cancel(mayInterruptIfRunning));
1387     f.complete(v1);
1388     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1389 jsr166 1.22
1390     checkCompletedWithWrappedCancellationException(h);
1391 jsr166 1.35 checkCancelled(g);
1392     assertFalse(r.ran());
1393     checkCompletedNormally(f, v1);
1394     }
1395 dl 1.5 }
1396    
1397 jsr166 1.35 public void testThenAcceptBoth_sourceCancelled4() {
1398     for (ExecutionMode m : ExecutionMode.values())
1399     for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1400     for (Integer v1 : new Integer[] { 1, null }) {
1401 jsr166 1.34
1402 jsr166 1.35 final CompletableFuture<Integer> f = new CompletableFuture<>();
1403     final CompletableFuture<Integer> g = new CompletableFuture<>();
1404     final SubtractAction r = new SubtractAction();
1405 jsr166 1.34
1406 jsr166 1.35 assertTrue(f.cancel(mayInterruptIfRunning));
1407     g.complete(v1);
1408     final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1409 jsr166 1.34
1410 jsr166 1.35 checkCompletedWithWrappedCancellationException(h);
1411     checkCancelled(f);
1412     assertFalse(r.ran());
1413     checkCompletedNormally(g, v1);
1414     }
1415 jsr166 1.34 }
1416    
1417     /**
1418 dl 1.5 * runAfterBoth result completes normally after normal
1419     * completion of sources
1420     */
1421 jsr166 1.33 public void testRunAfterBoth_normalCompletion1() {
1422 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1423 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null })
1424     for (Integer v2 : new Integer[] { 2, null }) {
1425    
1426     final CompletableFuture<Integer> f = new CompletableFuture<>();
1427     final CompletableFuture<Integer> g = new CompletableFuture<>();
1428     final Noop r = new Noop();
1429 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1430 jsr166 1.22
1431 jsr166 1.33 f.complete(v1);
1432 jsr166 1.22 checkIncomplete(h);
1433 jsr166 1.33 assertFalse(r.ran);
1434     g.complete(v2);
1435    
1436 jsr166 1.22 checkCompletedNormally(h, null);
1437     assertTrue(r.ran);
1438 jsr166 1.33 checkCompletedNormally(f, v1);
1439     checkCompletedNormally(g, v2);
1440     }
1441     }
1442    
1443     public void testRunAfterBoth_normalCompletion2() {
1444 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1445 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null })
1446     for (Integer v2 : new Integer[] { 2, null }) {
1447    
1448     final CompletableFuture<Integer> f = new CompletableFuture<>();
1449     final CompletableFuture<Integer> g = new CompletableFuture<>();
1450     final Noop r = new Noop();
1451 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1452 jsr166 1.22
1453 jsr166 1.33 g.complete(v2);
1454 jsr166 1.22 checkIncomplete(h);
1455 jsr166 1.33 assertFalse(r.ran);
1456     f.complete(v1);
1457    
1458     checkCompletedNormally(h, null);
1459     assertTrue(r.ran);
1460     checkCompletedNormally(f, v1);
1461     checkCompletedNormally(g, v2);
1462     }
1463     }
1464    
1465     public void testRunAfterBoth_normalCompletion3() {
1466 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1467 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null })
1468     for (Integer v2 : new Integer[] { 2, null }) {
1469    
1470     final CompletableFuture<Integer> f = new CompletableFuture<>();
1471     final CompletableFuture<Integer> g = new CompletableFuture<>();
1472     final Noop r = new Noop();
1473    
1474     g.complete(v2);
1475     f.complete(v1);
1476 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1477 jsr166 1.33
1478 jsr166 1.22 checkCompletedNormally(h, null);
1479 dl 1.5 assertTrue(r.ran);
1480 jsr166 1.33 checkCompletedNormally(f, v1);
1481     checkCompletedNormally(g, v2);
1482     }
1483     }
1484    
1485     public void testRunAfterBoth_normalCompletion4() {
1486 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1487 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null })
1488     for (Integer v2 : new Integer[] { 2, null }) {
1489    
1490     final CompletableFuture<Integer> f = new CompletableFuture<>();
1491     final CompletableFuture<Integer> g = new CompletableFuture<>();
1492     final Noop r = new Noop();
1493    
1494     f.complete(v1);
1495     g.complete(v2);
1496 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1497 dl 1.5
1498 jsr166 1.22 checkCompletedNormally(h, null);
1499 dl 1.5 assertTrue(r.ran);
1500 jsr166 1.33 checkCompletedNormally(f, v1);
1501     checkCompletedNormally(g, v2);
1502     }
1503 dl 1.5 }
1504    
1505     /**
1506     * runAfterBoth result completes exceptionally after exceptional
1507     * completion of either source
1508     */
1509 jsr166 1.33 public void testRunAfterBoth_exceptionalCompletion1() {
1510 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1511 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null }) {
1512    
1513     final CompletableFuture<Integer> f = new CompletableFuture<>();
1514     final CompletableFuture<Integer> g = new CompletableFuture<>();
1515     final Noop r = new Noop();
1516 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1517 jsr166 1.33 final CFException ex = new CFException();
1518 jsr166 1.22
1519 jsr166 1.33 f.completeExceptionally(ex);
1520 jsr166 1.22 checkIncomplete(h);
1521 jsr166 1.33 g.complete(v1);
1522    
1523     checkCompletedWithWrappedCFException(h, ex);
1524     checkCompletedWithWrappedCFException(f, ex);
1525 jsr166 1.22 assertFalse(r.ran);
1526 jsr166 1.33 checkCompletedNormally(g, v1);
1527     }
1528     }
1529 jsr166 1.22
1530 jsr166 1.33 public void testRunAfterBoth_exceptionalCompletion2() {
1531 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1532 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null }) {
1533    
1534     final CompletableFuture<Integer> f = new CompletableFuture<>();
1535     final CompletableFuture<Integer> g = new CompletableFuture<>();
1536     final Noop r = new Noop();
1537 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1538 jsr166 1.33 final CFException ex = new CFException();
1539    
1540     g.completeExceptionally(ex);
1541 jsr166 1.22 checkIncomplete(h);
1542 jsr166 1.33 f.complete(v1);
1543    
1544     checkCompletedWithWrappedCFException(h, ex);
1545     checkCompletedWithWrappedCFException(g, ex);
1546 jsr166 1.22 assertFalse(r.ran);
1547 jsr166 1.33 checkCompletedNormally(f, v1);
1548     }
1549     }
1550 jsr166 1.22
1551 jsr166 1.33 public void testRunAfterBoth_exceptionalCompletion3() {
1552 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1553 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null }) {
1554    
1555     final CompletableFuture<Integer> f = new CompletableFuture<>();
1556     final CompletableFuture<Integer> g = new CompletableFuture<>();
1557     final Noop r = new Noop();
1558     final CFException ex = new CFException();
1559    
1560     g.completeExceptionally(ex);
1561     f.complete(v1);
1562 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1563 jsr166 1.33
1564     checkCompletedWithWrappedCFException(h, ex);
1565     checkCompletedWithWrappedCFException(g, ex);
1566 jsr166 1.22 assertFalse(r.ran);
1567 jsr166 1.33 checkCompletedNormally(f, v1);
1568     }
1569     }
1570    
1571     public void testRunAfterBoth_exceptionalCompletion4() {
1572 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1573 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null }) {
1574    
1575     final CompletableFuture<Integer> f = new CompletableFuture<>();
1576     final CompletableFuture<Integer> g = new CompletableFuture<>();
1577     final Noop r = new Noop();
1578     final CFException ex = new CFException();
1579    
1580     f.completeExceptionally(ex);
1581     g.complete(v1);
1582 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1583 dl 1.5
1584 jsr166 1.33 checkCompletedWithWrappedCFException(h, ex);
1585     checkCompletedWithWrappedCFException(f, ex);
1586 jsr166 1.22 assertFalse(r.ran);
1587 jsr166 1.33 checkCompletedNormally(g, v1);
1588     }
1589 dl 1.5 }
1590    
1591 jsr166 1.4 /**
1592 dl 1.5 * runAfterBoth result completes exceptionally if action does
1593 jsr166 1.4 */
1594 jsr166 1.33 public void testRunAfterBoth_actionFailed1() {
1595 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1596 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null })
1597     for (Integer v2 : new Integer[] { 2, null }) {
1598    
1599     final CompletableFuture<Integer> f = new CompletableFuture<>();
1600     final CompletableFuture<Integer> g = new CompletableFuture<>();
1601     final FailingNoop r = new FailingNoop();
1602 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1603 jsr166 1.33
1604     f.complete(v1);
1605     checkIncomplete(h);
1606     g.complete(v2);
1607    
1608     checkCompletedWithWrappedCFException(h);
1609     checkCompletedNormally(f, v1);
1610     checkCompletedNormally(g, v2);
1611     }
1612     }
1613    
1614     public void testRunAfterBoth_actionFailed2() {
1615 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1616 jsr166 1.33 for (Integer v1 : new Integer[] { 1, null })
1617     for (Integer v2 : new Integer[] { 2, null }) {
1618    
1619     final CompletableFuture<Integer> f = new CompletableFuture<>();
1620     final CompletableFuture<Integer> g = new CompletableFuture<>();
1621     final FailingNoop r = new FailingNoop();
1622 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1623 jsr166 1.33
1624     g.complete(v2);
1625     checkIncomplete(h);
1626     f.complete(v1);
1627    
1628     checkCompletedWithWrappedCFException(h);
1629     checkCompletedNormally(f, v1);
1630     checkCompletedNormally(g, v2);
1631     }
1632 jsr166 1.4 }
1633    
1634     /**
1635 dl 1.5 * runAfterBoth result completes exceptionally if either source cancelled
1636 jsr166 1.4 */
1637 jsr166 1.33 public void testRunAfterBoth_sourceCancelled1() {
1638 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1639 jsr166 1.33 for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1640     for (Integer v1 : new Integer[] { 1, null }) {
1641    
1642     final CompletableFuture<Integer> f = new CompletableFuture<>();
1643     final CompletableFuture<Integer> g = new CompletableFuture<>();
1644     final Noop r = new Noop();
1645 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1646 jsr166 1.33
1647     assertTrue(f.cancel(mayInterruptIfRunning));
1648     checkIncomplete(h);
1649     g.complete(v1);
1650    
1651     checkCompletedWithWrappedCancellationException(h);
1652     checkCancelled(f);
1653     assertFalse(r.ran);
1654     checkCompletedNormally(g, v1);
1655     }
1656     }
1657    
1658     public void testRunAfterBoth_sourceCancelled2() {
1659 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1660 jsr166 1.33 for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1661     for (Integer v1 : new Integer[] { 1, null }) {
1662    
1663     final CompletableFuture<Integer> f = new CompletableFuture<>();
1664     final CompletableFuture<Integer> g = new CompletableFuture<>();
1665     final Noop r = new Noop();
1666 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1667 jsr166 1.33
1668     assertTrue(g.cancel(mayInterruptIfRunning));
1669     checkIncomplete(h);
1670     f.complete(v1);
1671    
1672     checkCompletedWithWrappedCancellationException(h);
1673     checkCancelled(g);
1674     assertFalse(r.ran);
1675     checkCompletedNormally(f, v1);
1676     }
1677     }
1678    
1679     public void testRunAfterBoth_sourceCancelled3() {
1680 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1681 jsr166 1.33 for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1682     for (Integer v1 : new Integer[] { 1, null }) {
1683    
1684     final CompletableFuture<Integer> f = new CompletableFuture<>();
1685     final CompletableFuture<Integer> g = new CompletableFuture<>();
1686     final Noop r = new Noop();
1687    
1688     assertTrue(g.cancel(mayInterruptIfRunning));
1689     f.complete(v1);
1690 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1691 jsr166 1.33
1692     checkCompletedWithWrappedCancellationException(h);
1693     checkCancelled(g);
1694     assertFalse(r.ran);
1695     checkCompletedNormally(f, v1);
1696     }
1697     }
1698    
1699     public void testRunAfterBoth_sourceCancelled4() {
1700 jsr166 1.34 for (ExecutionMode m : ExecutionMode.values())
1701 jsr166 1.33 for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1702     for (Integer v1 : new Integer[] { 1, null }) {
1703    
1704     final CompletableFuture<Integer> f = new CompletableFuture<>();
1705     final CompletableFuture<Integer> g = new CompletableFuture<>();
1706     final Noop r = new Noop();
1707    
1708     assertTrue(f.cancel(mayInterruptIfRunning));
1709     g.complete(v1);
1710 jsr166 1.34 final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1711 jsr166 1.33
1712     checkCompletedWithWrappedCancellationException(h);
1713     checkCancelled(f);
1714     assertFalse(r.ran);
1715     checkCompletedNormally(g, v1);
1716     }
1717 jsr166 1.4 }
1718 dl 1.5
1719     /**
1720     * applyToEither result completes normally after normal completion
1721     * of either source
1722     */
1723     public void testApplyToEither() {
1724 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1725     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1726 dl 1.5 CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1727     f.complete(one);
1728     checkCompletedNormally(g, two);
1729     f2.complete(one);
1730     checkCompletedNormally(g, two);
1731    
1732 jsr166 1.22 f = new CompletableFuture<>();
1733 dl 1.5 f.complete(one);
1734 jsr166 1.22 f2 = new CompletableFuture<>();
1735 dl 1.5 g = f.applyToEither(f2, inc);
1736     checkCompletedNormally(g, two);
1737     }
1738    
1739     /**
1740     * applyToEither result completes exceptionally after exceptional
1741     * completion of either source
1742     */
1743     public void testApplyToEither2() {
1744 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1745     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1746 dl 1.5 CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1747     f.completeExceptionally(new CFException());
1748     f2.complete(one);
1749     checkCompletedWithWrappedCFException(g);
1750    
1751 jsr166 1.22 f = new CompletableFuture<>();
1752     f2 = new CompletableFuture<>();
1753 dl 1.5 f2.completeExceptionally(new CFException());
1754     g = f.applyToEither(f2, inc);
1755     checkCompletedWithWrappedCFException(g);
1756     }
1757    
1758     /**
1759     * applyToEither result completes exceptionally if action does
1760     */
1761     public void testApplyToEither3() {
1762 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1763     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1764 dl 1.5 FailingFunction r = new FailingFunction();
1765     CompletableFuture<Integer> g = f.applyToEither(f2, r);
1766     f2.complete(two);
1767     checkCompletedWithWrappedCFException(g);
1768     }
1769    
1770     /**
1771     * applyToEither result completes exceptionally if either source cancelled
1772     */
1773     public void testApplyToEither4() {
1774 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1775     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1776 dl 1.5 CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1777     assertTrue(f.cancel(true));
1778     checkCompletedWithWrappedCancellationException(g);
1779 jsr166 1.22 f = new CompletableFuture<>();
1780     f2 = new CompletableFuture<>();
1781 dl 1.5 assertTrue(f2.cancel(true));
1782     checkCompletedWithWrappedCancellationException(g);
1783     }
1784    
1785     /**
1786     * acceptEither result completes normally after normal completion
1787     * of either source
1788     */
1789     public void testAcceptEither() {
1790 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1791     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1792 dl 1.5 IncAction r = new IncAction();
1793     CompletableFuture<Void> g = f.acceptEither(f2, r);
1794     f.complete(one);
1795     checkCompletedNormally(g, null);
1796     f2.complete(one);
1797     checkCompletedNormally(g, null);
1798     assertEquals(r.value, 2);
1799    
1800     r = new IncAction();
1801 jsr166 1.22 f = new CompletableFuture<>();
1802 dl 1.5 f.complete(one);
1803 jsr166 1.22 f2 = new CompletableFuture<>();
1804 dl 1.5 g = f.acceptEither(f2, r);
1805     checkCompletedNormally(g, null);
1806     assertEquals(r.value, 2);
1807     }
1808    
1809     /**
1810     * acceptEither result completes exceptionally after exceptional
1811     * completion of either source
1812     */
1813     public void testAcceptEither2() {
1814 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1815     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1816 dl 1.5 IncAction r = new IncAction();
1817     CompletableFuture<Void> g = f.acceptEither(f2, r);
1818     f.completeExceptionally(new CFException());
1819     f2.complete(one);
1820     checkCompletedWithWrappedCFException(g);
1821    
1822     r = new IncAction();
1823 jsr166 1.22 f = new CompletableFuture<>();
1824     f2 = new CompletableFuture<>();
1825 dl 1.5 f2.completeExceptionally(new CFException());
1826     g = f.acceptEither(f2, r);
1827     checkCompletedWithWrappedCFException(g);
1828     }
1829    
1830     /**
1831     * acceptEither result completes exceptionally if action does
1832     */
1833     public void testAcceptEither3() {
1834 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1835     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1836 dl 1.5 FailingConsumer r = new FailingConsumer();
1837     CompletableFuture<Void> g = f.acceptEither(f2, r);
1838     f2.complete(two);
1839     checkCompletedWithWrappedCFException(g);
1840     }
1841    
1842     /**
1843     * acceptEither result completes exceptionally if either source cancelled
1844     */
1845     public void testAcceptEither4() {
1846 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1847     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1848 dl 1.5 IncAction r = new IncAction();
1849     CompletableFuture<Void> g = f.acceptEither(f2, r);
1850     assertTrue(f.cancel(true));
1851     checkCompletedWithWrappedCancellationException(g);
1852 jsr166 1.22 f = new CompletableFuture<>();
1853     f2 = new CompletableFuture<>();
1854 dl 1.5 assertTrue(f2.cancel(true));
1855     checkCompletedWithWrappedCancellationException(g);
1856     }
1857    
1858     /**
1859     * runAfterEither result completes normally after normal completion
1860     * of either source
1861     */
1862     public void testRunAfterEither() {
1863 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1864     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1865 dl 1.5 Noop r = new Noop();
1866     CompletableFuture<Void> g = f.runAfterEither(f2, r);
1867     f.complete(one);
1868     checkCompletedNormally(g, null);
1869     f2.complete(one);
1870     checkCompletedNormally(g, null);
1871     assertTrue(r.ran);
1872    
1873     r = new Noop();
1874 jsr166 1.22 f = new CompletableFuture<>();
1875 dl 1.5 f.complete(one);
1876 jsr166 1.22 f2 = new CompletableFuture<>();
1877 dl 1.5 g = f.runAfterEither(f2, r);
1878     checkCompletedNormally(g, null);
1879     assertTrue(r.ran);
1880     }
1881    
1882     /**
1883     * runAfterEither result completes exceptionally after exceptional
1884     * completion of either source
1885     */
1886     public void testRunAfterEither2() {
1887 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1888     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1889 dl 1.5 Noop r = new Noop();
1890     CompletableFuture<Void> g = f.runAfterEither(f2, r);
1891     f.completeExceptionally(new CFException());
1892     f2.complete(one);
1893     checkCompletedWithWrappedCFException(g);
1894    
1895     r = new Noop();
1896 jsr166 1.22 f = new CompletableFuture<>();
1897     f2 = new CompletableFuture<>();
1898 dl 1.5 f2.completeExceptionally(new CFException());
1899     g = f.runAfterEither(f2, r);
1900     checkCompletedWithWrappedCFException(g);
1901     }
1902    
1903     /**
1904     * runAfterEither result completes exceptionally if action does
1905     */
1906     public void testRunAfterEither3() {
1907 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1908     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1909 dl 1.5 FailingNoop r = new FailingNoop();
1910     CompletableFuture<Void> g = f.runAfterEither(f2, r);
1911     f2.complete(two);
1912     checkCompletedWithWrappedCFException(g);
1913     }
1914    
1915     /**
1916     * runAfterEither result completes exceptionally if either source cancelled
1917     */
1918     public void testRunAfterEither4() {
1919 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
1920     CompletableFuture<Integer> f2 = new CompletableFuture<>();
1921 dl 1.5 Noop r = new Noop();
1922     CompletableFuture<Void> g = f.runAfterEither(f2, r);
1923     assertTrue(f.cancel(true));
1924     checkCompletedWithWrappedCancellationException(g);
1925 jsr166 1.22 f = new CompletableFuture<>();
1926     f2 = new CompletableFuture<>();
1927 dl 1.5 assertTrue(f2.cancel(true));
1928     checkCompletedWithWrappedCancellationException(g);
1929     }
1930    
1931     /**
1932     * thenCompose result completes normally after normal completion of source
1933     */
1934     public void testThenCompose() {
1935 jsr166 1.21 CompletableFuture<Integer> f, g;
1936     CompletableFutureInc r;
1937    
1938 jsr166 1.22 f = new CompletableFuture<>();
1939 jsr166 1.21 g = f.thenCompose(r = new CompletableFutureInc());
1940     f.complete(one);
1941     checkCompletedNormally(g, two);
1942     assertTrue(r.ran);
1943    
1944 jsr166 1.22 f = new CompletableFuture<>();
1945 dl 1.5 f.complete(one);
1946 jsr166 1.21 g = f.thenCompose(r = new CompletableFutureInc());
1947 dl 1.5 checkCompletedNormally(g, two);
1948 jsr166 1.21 assertTrue(r.ran);
1949 dl 1.5 }
1950    
1951     /**
1952     * thenCompose result completes exceptionally after exceptional
1953     * completion of source
1954     */
1955     public void testThenCompose2() {
1956 jsr166 1.21 CompletableFuture<Integer> f, g;
1957     CompletableFutureInc r;
1958    
1959 jsr166 1.22 f = new CompletableFuture<>();
1960 jsr166 1.21 g = f.thenCompose(r = new CompletableFutureInc());
1961     f.completeExceptionally(new CFException());
1962     checkCompletedWithWrappedCFException(g);
1963    
1964 jsr166 1.22 f = new CompletableFuture<>();
1965 dl 1.5 f.completeExceptionally(new CFException());
1966 jsr166 1.21 g = f.thenCompose(r = new CompletableFutureInc());
1967 dl 1.5 checkCompletedWithWrappedCFException(g);
1968     }
1969    
1970     /**
1971     * thenCompose result completes exceptionally if action does
1972     */
1973     public void testThenCompose3() {
1974 jsr166 1.21 CompletableFuture<Integer> f, g;
1975     FailingCompletableFutureFunction r;
1976    
1977 jsr166 1.22 f = new CompletableFuture<>();
1978 jsr166 1.21 g = f.thenCompose(r = new FailingCompletableFutureFunction());
1979     f.complete(one);
1980     checkCompletedWithWrappedCFException(g);
1981    
1982 jsr166 1.22 f = new CompletableFuture<>();
1983 dl 1.5 f.complete(one);
1984 jsr166 1.21 g = f.thenCompose(r = new FailingCompletableFutureFunction());
1985 dl 1.5 checkCompletedWithWrappedCFException(g);
1986     }
1987    
1988     /**
1989     * thenCompose result completes exceptionally if source cancelled
1990     */
1991     public void testThenCompose4() {
1992 jsr166 1.21 CompletableFuture<Integer> f, g;
1993     CompletableFutureInc r;
1994    
1995 jsr166 1.22 f = new CompletableFuture<>();
1996 jsr166 1.21 g = f.thenCompose(r = new CompletableFutureInc());
1997     assertTrue(f.cancel(true));
1998     checkCompletedWithWrappedCancellationException(g);
1999    
2000 jsr166 1.22 f = new CompletableFuture<>();
2001 dl 1.5 assertTrue(f.cancel(true));
2002 jsr166 1.21 g = f.thenCompose(r = new CompletableFutureInc());
2003 dl 1.5 checkCompletedWithWrappedCancellationException(g);
2004     }
2005    
2006     // asyncs
2007    
2008     /**
2009     * thenRunAsync result completes normally after normal completion of source
2010     */
2011     public void testThenRunAsync() {
2012 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2013 dl 1.5 Noop r = new Noop();
2014     CompletableFuture<Void> g = f.thenRunAsync(r);
2015     f.complete(null);
2016     checkCompletedNormally(g, null);
2017    
2018     // reordered version
2019 jsr166 1.22 f = new CompletableFuture<>();
2020 dl 1.5 f.complete(null);
2021     r = new Noop();
2022     g = f.thenRunAsync(r);
2023     checkCompletedNormally(g, null);
2024     }
2025    
2026     /**
2027     * thenRunAsync result completes exceptionally after exceptional
2028     * completion of source
2029     */
2030     public void testThenRunAsync2() {
2031 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2032 dl 1.5 Noop r = new Noop();
2033     CompletableFuture<Void> g = f.thenRunAsync(r);
2034     f.completeExceptionally(new CFException());
2035     try {
2036     g.join();
2037     shouldThrow();
2038 jsr166 1.29 } catch (CompletionException success) {}
2039 dl 1.5 checkCompletedWithWrappedCFException(g);
2040     }
2041    
2042     /**
2043     * thenRunAsync result completes exceptionally if action does
2044     */
2045     public void testThenRunAsync3() {
2046 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2047 dl 1.5 FailingNoop r = new FailingNoop();
2048     CompletableFuture<Void> g = f.thenRunAsync(r);
2049     f.complete(null);
2050     checkCompletedWithWrappedCFException(g);
2051     }
2052 jsr166 1.6
2053 dl 1.5 /**
2054     * thenRunAsync result completes exceptionally if source cancelled
2055     */
2056     public void testThenRunAsync4() {
2057 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2058 dl 1.5 Noop r = new Noop();
2059     CompletableFuture<Void> g = f.thenRunAsync(r);
2060     assertTrue(f.cancel(true));
2061     checkCompletedWithWrappedCancellationException(g);
2062     }
2063    
2064     /**
2065     * thenApplyAsync result completes normally after normal completion of source
2066     */
2067     public void testThenApplyAsync() {
2068 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2069 dl 1.5 CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2070     f.complete(one);
2071     checkCompletedNormally(g, two);
2072     }
2073    
2074     /**
2075     * thenApplyAsync result completes exceptionally after exceptional
2076     * completion of source
2077     */
2078     public void testThenApplyAsync2() {
2079 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2080 dl 1.5 CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2081     f.completeExceptionally(new CFException());
2082     checkCompletedWithWrappedCFException(g);
2083     }
2084    
2085     /**
2086     * thenApplyAsync result completes exceptionally if action does
2087     */
2088     public void testThenApplyAsync3() {
2089 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2090 dl 1.5 FailingFunction r = new FailingFunction();
2091     CompletableFuture<Integer> g = f.thenApplyAsync(r);
2092     f.complete(null);
2093     checkCompletedWithWrappedCFException(g);
2094     }
2095 jsr166 1.6
2096 dl 1.5 /**
2097     * thenApplyAsync result completes exceptionally if source cancelled
2098     */
2099     public void testThenApplyAsync4() {
2100 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2101 dl 1.5 CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2102     assertTrue(f.cancel(true));
2103     checkCompletedWithWrappedCancellationException(g);
2104     }
2105    
2106     /**
2107     * thenAcceptAsync result completes normally after normal
2108     * completion of source
2109     */
2110     public void testThenAcceptAsync() {
2111 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2112 dl 1.5 IncAction r = new IncAction();
2113     CompletableFuture<Void> g = f.thenAcceptAsync(r);
2114     f.complete(one);
2115     checkCompletedNormally(g, null);
2116     assertEquals(r.value, 2);
2117     }
2118    
2119     /**
2120     * thenAcceptAsync result completes exceptionally after exceptional
2121     * completion of source
2122     */
2123     public void testThenAcceptAsync2() {
2124 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2125 dl 1.5 IncAction r = new IncAction();
2126     CompletableFuture<Void> g = f.thenAcceptAsync(r);
2127     f.completeExceptionally(new CFException());
2128     checkCompletedWithWrappedCFException(g);
2129     }
2130    
2131     /**
2132     * thenAcceptAsync result completes exceptionally if action does
2133     */
2134     public void testThenAcceptAsync3() {
2135 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2136 dl 1.5 FailingConsumer r = new FailingConsumer();
2137     CompletableFuture<Void> g = f.thenAcceptAsync(r);
2138     f.complete(null);
2139     checkCompletedWithWrappedCFException(g);
2140     }
2141 jsr166 1.6
2142 dl 1.5 /**
2143     * thenAcceptAsync result completes exceptionally if source cancelled
2144     */
2145     public void testThenAcceptAsync4() {
2146 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2147 dl 1.5 IncAction r = new IncAction();
2148     CompletableFuture<Void> g = f.thenAcceptAsync(r);
2149     assertTrue(f.cancel(true));
2150     checkCompletedWithWrappedCancellationException(g);
2151     }
2152 jsr166 1.19
2153 dl 1.5 /**
2154     * applyToEitherAsync result completes normally after normal
2155     * completion of sources
2156     */
2157     public void testApplyToEitherAsync() {
2158 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2159     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2160 dl 1.5 CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2161     f.complete(one);
2162     checkCompletedNormally(g, two);
2163    
2164 jsr166 1.22 f = new CompletableFuture<>();
2165 dl 1.5 f.complete(one);
2166 jsr166 1.22 f2 = new CompletableFuture<>();
2167 dl 1.5 g = f.applyToEitherAsync(f2, inc);
2168     checkCompletedNormally(g, two);
2169     }
2170    
2171     /**
2172     * applyToEitherAsync result completes exceptionally after exceptional
2173     * completion of source
2174     */
2175     public void testApplyToEitherAsync2() {
2176 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2177     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2178 dl 1.5 CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2179     f.completeExceptionally(new CFException());
2180     checkCompletedWithWrappedCFException(g);
2181    
2182 jsr166 1.22 f = new CompletableFuture<>();
2183     f2 = new CompletableFuture<>();
2184 dl 1.5 f2.completeExceptionally(new CFException());
2185     g = f.applyToEitherAsync(f2, inc);
2186     f.complete(one);
2187     checkCompletedWithWrappedCFException(g);
2188     }
2189    
2190     /**
2191     * applyToEitherAsync result completes exceptionally if action does
2192     */
2193     public void testApplyToEitherAsync3() {
2194 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2195     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2196 dl 1.5 FailingFunction r = new FailingFunction();
2197 jsr166 1.6 CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r);
2198 dl 1.5 f.complete(one);
2199     checkCompletedWithWrappedCFException(g);
2200     }
2201 jsr166 1.6
2202 dl 1.5 /**
2203     * applyToEitherAsync result completes exceptionally if either source cancelled
2204     */
2205     public void testApplyToEitherAsync4() {
2206 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2207     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2208 dl 1.5 CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
2209     assertTrue(f.cancel(true));
2210     checkCompletedWithWrappedCancellationException(g);
2211 jsr166 1.6
2212 jsr166 1.22 f = new CompletableFuture<>();
2213     f2 = new CompletableFuture<>();
2214 dl 1.5 assertTrue(f2.cancel(true));
2215     g = f.applyToEitherAsync(f2, inc);
2216     checkCompletedWithWrappedCancellationException(g);
2217     }
2218    
2219     /**
2220     * acceptEitherAsync result completes normally after normal
2221     * completion of sources
2222     */
2223     public void testAcceptEitherAsync() {
2224 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2225     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2226 dl 1.5 IncAction r = new IncAction();
2227     CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2228     f.complete(one);
2229     checkCompletedNormally(g, null);
2230     assertEquals(r.value, 2);
2231    
2232     r = new IncAction();
2233 jsr166 1.22 f = new CompletableFuture<>();
2234 dl 1.5 f.complete(one);
2235 jsr166 1.22 f2 = new CompletableFuture<>();
2236 dl 1.5 g = f.acceptEitherAsync(f2, r);
2237     checkCompletedNormally(g, null);
2238     assertEquals(r.value, 2);
2239     }
2240    
2241     /**
2242     * acceptEitherAsync result completes exceptionally after exceptional
2243     * completion of source
2244     */
2245     public void testAcceptEitherAsync2() {
2246 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2247     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2248 dl 1.5 IncAction r = new IncAction();
2249     CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2250     f.completeExceptionally(new CFException());
2251     checkCompletedWithWrappedCFException(g);
2252    
2253     r = new IncAction();
2254 jsr166 1.22 f = new CompletableFuture<>();
2255     f2 = new CompletableFuture<>();
2256 dl 1.5 f2.completeExceptionally(new CFException());
2257     g = f.acceptEitherAsync(f2, r);
2258     f.complete(one);
2259     checkCompletedWithWrappedCFException(g);
2260     }
2261    
2262     /**
2263     * acceptEitherAsync result completes exceptionally if action does
2264     */
2265     public void testAcceptEitherAsync3() {
2266 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2267     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2268 dl 1.5 FailingConsumer r = new FailingConsumer();
2269 jsr166 1.6 CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2270 dl 1.5 f.complete(one);
2271     checkCompletedWithWrappedCFException(g);
2272     }
2273 jsr166 1.6
2274 dl 1.5 /**
2275     * acceptEitherAsync result completes exceptionally if either
2276     * source cancelled
2277     */
2278     public void testAcceptEitherAsync4() {
2279 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2280     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2281 dl 1.5 IncAction r = new IncAction();
2282     CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2283     assertTrue(f.cancel(true));
2284     checkCompletedWithWrappedCancellationException(g);
2285 jsr166 1.6
2286 dl 1.5 r = new IncAction();
2287 jsr166 1.22 f = new CompletableFuture<>();
2288     f2 = new CompletableFuture<>();
2289 dl 1.5 assertTrue(f2.cancel(true));
2290     g = f.acceptEitherAsync(f2, r);
2291     checkCompletedWithWrappedCancellationException(g);
2292     }
2293    
2294     /**
2295     * runAfterEitherAsync result completes normally after normal
2296     * completion of sources
2297     */
2298     public void testRunAfterEitherAsync() {
2299 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2300     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2301 dl 1.5 Noop r = new Noop();
2302     CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2303     f.complete(one);
2304     checkCompletedNormally(g, null);
2305     assertTrue(r.ran);
2306    
2307     r = new Noop();
2308 jsr166 1.22 f = new CompletableFuture<>();
2309 dl 1.5 f.complete(one);
2310 jsr166 1.22 f2 = new CompletableFuture<>();
2311 dl 1.5 g = f.runAfterEitherAsync(f2, r);
2312     checkCompletedNormally(g, null);
2313     assertTrue(r.ran);
2314     }
2315    
2316     /**
2317     * runAfterEitherAsync result completes exceptionally after exceptional
2318     * completion of source
2319     */
2320     public void testRunAfterEitherAsync2() {
2321 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2322     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2323 dl 1.5 Noop r = new Noop();
2324     CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2325     f.completeExceptionally(new CFException());
2326     checkCompletedWithWrappedCFException(g);
2327    
2328     r = new Noop();
2329 jsr166 1.22 f = new CompletableFuture<>();
2330     f2 = new CompletableFuture<>();
2331 dl 1.5 f2.completeExceptionally(new CFException());
2332     g = f.runAfterEitherAsync(f2, r);
2333     f.complete(one);
2334     checkCompletedWithWrappedCFException(g);
2335     }
2336    
2337     /**
2338     * runAfterEitherAsync result completes exceptionally if action does
2339     */
2340     public void testRunAfterEitherAsync3() {
2341 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2342     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2343 dl 1.5 FailingNoop r = new FailingNoop();
2344 jsr166 1.6 CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2345 dl 1.5 f.complete(one);
2346     checkCompletedWithWrappedCFException(g);
2347     }
2348 jsr166 1.6
2349 dl 1.5 /**
2350     * runAfterEitherAsync result completes exceptionally if either
2351     * source cancelled
2352     */
2353     public void testRunAfterEitherAsync4() {
2354 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2355     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2356 dl 1.5 Noop r = new Noop();
2357     CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2358     assertTrue(f.cancel(true));
2359     checkCompletedWithWrappedCancellationException(g);
2360 jsr166 1.6
2361 dl 1.5 r = new Noop();
2362 jsr166 1.22 f = new CompletableFuture<>();
2363     f2 = new CompletableFuture<>();
2364 dl 1.5 assertTrue(f2.cancel(true));
2365     g = f.runAfterEitherAsync(f2, r);
2366     checkCompletedWithWrappedCancellationException(g);
2367     }
2368    
2369     /**
2370 jsr166 1.7 * thenComposeAsync result completes normally after normal
2371     * completion of source
2372 dl 1.5 */
2373     public void testThenComposeAsync() {
2374 jsr166 1.20 CompletableFuture<Integer> f, g;
2375     CompletableFutureInc r;
2376    
2377 jsr166 1.22 f = new CompletableFuture<>();
2378 jsr166 1.20 g = f.thenComposeAsync(r = new CompletableFutureInc());
2379     f.complete(one);
2380     checkCompletedNormally(g, two);
2381    
2382 jsr166 1.22 f = new CompletableFuture<>();
2383 dl 1.5 f.complete(one);
2384 jsr166 1.20 g = f.thenComposeAsync(r = new CompletableFutureInc());
2385 dl 1.5 checkCompletedNormally(g, two);
2386     }
2387    
2388     /**
2389 jsr166 1.7 * thenComposeAsync result completes exceptionally after
2390     * exceptional completion of source
2391 dl 1.5 */
2392     public void testThenComposeAsync2() {
2393 jsr166 1.20 CompletableFuture<Integer> f, g;
2394     CompletableFutureInc r;
2395    
2396 jsr166 1.22 f = new CompletableFuture<>();
2397 jsr166 1.20 g = f.thenComposeAsync(r = new CompletableFutureInc());
2398     f.completeExceptionally(new CFException());
2399     checkCompletedWithWrappedCFException(g);
2400     assertFalse(r.ran);
2401    
2402 jsr166 1.22 f = new CompletableFuture<>();
2403 dl 1.5 f.completeExceptionally(new CFException());
2404 jsr166 1.20 g = f.thenComposeAsync(r = new CompletableFutureInc());
2405 dl 1.5 checkCompletedWithWrappedCFException(g);
2406 jsr166 1.20 assertFalse(r.ran);
2407 dl 1.5 }
2408    
2409     /**
2410     * thenComposeAsync result completes exceptionally if action does
2411     */
2412     public void testThenComposeAsync3() {
2413 jsr166 1.20 CompletableFuture<Integer> f, g;
2414     FailingCompletableFutureFunction r;
2415 jsr166 1.21
2416 jsr166 1.22 f = new CompletableFuture<>();
2417 jsr166 1.20 g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2418     f.complete(one);
2419     checkCompletedWithWrappedCFException(g);
2420 jsr166 1.21
2421 jsr166 1.22 f = new CompletableFuture<>();
2422 dl 1.5 f.complete(one);
2423 jsr166 1.20 g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2424 dl 1.5 checkCompletedWithWrappedCFException(g);
2425     }
2426    
2427     /**
2428     * thenComposeAsync result completes exceptionally if source cancelled
2429     */
2430     public void testThenComposeAsync4() {
2431 jsr166 1.20 CompletableFuture<Integer> f, g;
2432     CompletableFutureInc r;
2433    
2434 jsr166 1.22 f = new CompletableFuture<>();
2435 jsr166 1.20 g = f.thenComposeAsync(r = new CompletableFutureInc());
2436     assertTrue(f.cancel(true));
2437     checkCompletedWithWrappedCancellationException(g);
2438    
2439 jsr166 1.22 f = new CompletableFuture<>();
2440 dl 1.5 assertTrue(f.cancel(true));
2441 jsr166 1.20 g = f.thenComposeAsync(r = new CompletableFutureInc());
2442 dl 1.5 checkCompletedWithWrappedCancellationException(g);
2443     }
2444    
2445 jsr166 1.7 // async with explicit executors
2446 dl 1.5
2447     /**
2448     * thenRunAsync result completes normally after normal completion of source
2449     */
2450     public void testThenRunAsyncE() {
2451 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2452 dl 1.5 Noop r = new Noop();
2453     CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2454     f.complete(null);
2455     checkCompletedNormally(g, null);
2456    
2457     // reordered version
2458 jsr166 1.22 f = new CompletableFuture<>();
2459 dl 1.5 f.complete(null);
2460     r = new Noop();
2461     g = f.thenRunAsync(r, new ThreadExecutor());
2462     checkCompletedNormally(g, null);
2463     }
2464    
2465     /**
2466     * thenRunAsync result completes exceptionally after exceptional
2467     * completion of source
2468     */
2469     public void testThenRunAsync2E() {
2470 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2471 dl 1.5 Noop r = new Noop();
2472     CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2473     f.completeExceptionally(new CFException());
2474     try {
2475     g.join();
2476     shouldThrow();
2477 jsr166 1.29 } catch (CompletionException success) {}
2478 dl 1.5 checkCompletedWithWrappedCFException(g);
2479     }
2480    
2481     /**
2482     * thenRunAsync result completes exceptionally if action does
2483     */
2484     public void testThenRunAsync3E() {
2485 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2486 dl 1.5 FailingNoop r = new FailingNoop();
2487     CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2488     f.complete(null);
2489     checkCompletedWithWrappedCFException(g);
2490     }
2491 jsr166 1.6
2492 dl 1.5 /**
2493     * thenRunAsync result completes exceptionally if source cancelled
2494     */
2495     public void testThenRunAsync4E() {
2496 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2497 dl 1.5 Noop r = new Noop();
2498     CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2499     assertTrue(f.cancel(true));
2500     checkCompletedWithWrappedCancellationException(g);
2501     }
2502    
2503     /**
2504     * thenApplyAsync result completes normally after normal completion of source
2505     */
2506     public void testThenApplyAsyncE() {
2507 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2508 dl 1.5 CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2509     f.complete(one);
2510     checkCompletedNormally(g, two);
2511     }
2512    
2513     /**
2514     * thenApplyAsync result completes exceptionally after exceptional
2515     * completion of source
2516     */
2517     public void testThenApplyAsync2E() {
2518 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2519 dl 1.5 CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2520     f.completeExceptionally(new CFException());
2521     checkCompletedWithWrappedCFException(g);
2522     }
2523    
2524     /**
2525     * thenApplyAsync result completes exceptionally if action does
2526     */
2527     public void testThenApplyAsync3E() {
2528 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2529 dl 1.5 FailingFunction r = new FailingFunction();
2530     CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
2531     f.complete(null);
2532     checkCompletedWithWrappedCFException(g);
2533     }
2534 jsr166 1.6
2535 dl 1.5 /**
2536     * thenApplyAsync result completes exceptionally if source cancelled
2537     */
2538     public void testThenApplyAsync4E() {
2539 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2540 dl 1.5 CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2541     assertTrue(f.cancel(true));
2542     checkCompletedWithWrappedCancellationException(g);
2543     }
2544    
2545     /**
2546     * thenAcceptAsync result completes normally after normal
2547     * completion of source
2548     */
2549     public void testThenAcceptAsyncE() {
2550 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2551 dl 1.5 IncAction r = new IncAction();
2552     CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2553     f.complete(one);
2554     checkCompletedNormally(g, null);
2555     assertEquals(r.value, 2);
2556     }
2557    
2558     /**
2559     * thenAcceptAsync result completes exceptionally after exceptional
2560     * completion of source
2561     */
2562     public void testThenAcceptAsync2E() {
2563 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2564 dl 1.5 IncAction r = new IncAction();
2565     CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2566     f.completeExceptionally(new CFException());
2567     checkCompletedWithWrappedCFException(g);
2568     }
2569    
2570     /**
2571     * thenAcceptAsync result completes exceptionally if action does
2572     */
2573     public void testThenAcceptAsync3E() {
2574 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2575 dl 1.5 FailingConsumer r = new FailingConsumer();
2576     CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2577     f.complete(null);
2578     checkCompletedWithWrappedCFException(g);
2579     }
2580 jsr166 1.6
2581 dl 1.5 /**
2582     * thenAcceptAsync result completes exceptionally if source cancelled
2583     */
2584     public void testThenAcceptAsync4E() {
2585 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2586 dl 1.5 IncAction r = new IncAction();
2587     CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2588     assertTrue(f.cancel(true));
2589     checkCompletedWithWrappedCancellationException(g);
2590     }
2591 jsr166 1.18
2592 dl 1.5 /**
2593     * applyToEitherAsync result completes normally after normal
2594     * completion of sources
2595     */
2596     public void testApplyToEitherAsyncE() {
2597 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2598     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2599 dl 1.5 CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2600     f.complete(one);
2601     checkCompletedNormally(g, two);
2602    
2603 jsr166 1.22 f = new CompletableFuture<>();
2604 dl 1.5 f.complete(one);
2605 jsr166 1.22 f2 = new CompletableFuture<>();
2606 dl 1.5 g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2607     checkCompletedNormally(g, two);
2608     }
2609    
2610     /**
2611     * applyToEitherAsync result completes exceptionally after exceptional
2612     * completion of source
2613     */
2614     public void testApplyToEitherAsync2E() {
2615 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2616     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2617 dl 1.5 CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2618     f.completeExceptionally(new CFException());
2619     checkCompletedWithWrappedCFException(g);
2620    
2621 jsr166 1.22 f = new CompletableFuture<>();
2622     f2 = new CompletableFuture<>();
2623 dl 1.5 f2.completeExceptionally(new CFException());
2624     g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2625     f.complete(one);
2626     checkCompletedWithWrappedCFException(g);
2627     }
2628    
2629     /**
2630     * applyToEitherAsync result completes exceptionally if action does
2631     */
2632     public void testApplyToEitherAsync3E() {
2633 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2634     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2635 dl 1.5 FailingFunction r = new FailingFunction();
2636 jsr166 1.6 CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r, new ThreadExecutor());
2637 dl 1.5 f.complete(one);
2638     checkCompletedWithWrappedCFException(g);
2639     }
2640 jsr166 1.6
2641 dl 1.5 /**
2642     * applyToEitherAsync result completes exceptionally if either source cancelled
2643     */
2644     public void testApplyToEitherAsync4E() {
2645 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2646     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2647 dl 1.5 CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2648     assertTrue(f.cancel(true));
2649     checkCompletedWithWrappedCancellationException(g);
2650 jsr166 1.6
2651 jsr166 1.22 f = new CompletableFuture<>();
2652     f2 = new CompletableFuture<>();
2653 dl 1.5 assertTrue(f2.cancel(true));
2654     g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2655     checkCompletedWithWrappedCancellationException(g);
2656     }
2657    
2658     /**
2659     * acceptEitherAsync result completes normally after normal
2660     * completion of sources
2661     */
2662     public void testAcceptEitherAsyncE() {
2663 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2664     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2665 dl 1.5 IncAction r = new IncAction();
2666     CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2667     f.complete(one);
2668     checkCompletedNormally(g, null);
2669     assertEquals(r.value, 2);
2670    
2671     r = new IncAction();
2672 jsr166 1.22 f = new CompletableFuture<>();
2673 dl 1.5 f.complete(one);
2674 jsr166 1.22 f2 = new CompletableFuture<>();
2675 dl 1.5 g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2676     checkCompletedNormally(g, null);
2677     assertEquals(r.value, 2);
2678     }
2679    
2680     /**
2681     * acceptEitherAsync result completes exceptionally after exceptional
2682     * completion of source
2683     */
2684     public void testAcceptEitherAsync2E() {
2685 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2686     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2687 dl 1.5 IncAction r = new IncAction();
2688     CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2689     f.completeExceptionally(new CFException());
2690     checkCompletedWithWrappedCFException(g);
2691    
2692     r = new IncAction();
2693 jsr166 1.22 f = new CompletableFuture<>();
2694     f2 = new CompletableFuture<>();
2695 dl 1.5 f2.completeExceptionally(new CFException());
2696     g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2697     f.complete(one);
2698     checkCompletedWithWrappedCFException(g);
2699     }
2700    
2701     /**
2702     * acceptEitherAsync result completes exceptionally if action does
2703     */
2704     public void testAcceptEitherAsync3E() {
2705 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2706     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2707 dl 1.5 FailingConsumer r = new FailingConsumer();
2708 jsr166 1.6 CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2709 dl 1.5 f.complete(one);
2710     checkCompletedWithWrappedCFException(g);
2711     }
2712 jsr166 1.6
2713 dl 1.5 /**
2714     * acceptEitherAsync result completes exceptionally if either
2715     * source cancelled
2716     */
2717     public void testAcceptEitherAsync4E() {
2718 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2719     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2720 dl 1.5 IncAction r = new IncAction();
2721     CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2722     assertTrue(f.cancel(true));
2723     checkCompletedWithWrappedCancellationException(g);
2724 jsr166 1.6
2725 dl 1.5 r = new IncAction();
2726 jsr166 1.22 f = new CompletableFuture<>();
2727     f2 = new CompletableFuture<>();
2728 dl 1.5 assertTrue(f2.cancel(true));
2729     g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2730     checkCompletedWithWrappedCancellationException(g);
2731     }
2732    
2733     /**
2734     * runAfterEitherAsync result completes normally after normal
2735     * completion of sources
2736     */
2737     public void testRunAfterEitherAsyncE() {
2738 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2739     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2740 dl 1.5 Noop r = new Noop();
2741     CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2742     f.complete(one);
2743     checkCompletedNormally(g, null);
2744     assertTrue(r.ran);
2745    
2746     r = new Noop();
2747 jsr166 1.22 f = new CompletableFuture<>();
2748 dl 1.5 f.complete(one);
2749 jsr166 1.22 f2 = new CompletableFuture<>();
2750 dl 1.5 g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2751     checkCompletedNormally(g, null);
2752     assertTrue(r.ran);
2753     }
2754    
2755     /**
2756     * runAfterEitherAsync result completes exceptionally after exceptional
2757     * completion of source
2758     */
2759     public void testRunAfterEitherAsync2E() {
2760 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2761     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2762 dl 1.5 Noop r = new Noop();
2763     CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2764     f.completeExceptionally(new CFException());
2765     checkCompletedWithWrappedCFException(g);
2766    
2767     r = new Noop();
2768 jsr166 1.22 f = new CompletableFuture<>();
2769     f2 = new CompletableFuture<>();
2770 dl 1.5 f2.completeExceptionally(new CFException());
2771     g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2772     f.complete(one);
2773     checkCompletedWithWrappedCFException(g);
2774     }
2775    
2776     /**
2777     * runAfterEitherAsync result completes exceptionally if action does
2778     */
2779     public void testRunAfterEitherAsync3E() {
2780 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2781     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2782 dl 1.5 FailingNoop r = new FailingNoop();
2783 jsr166 1.6 CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2784 dl 1.5 f.complete(one);
2785     checkCompletedWithWrappedCFException(g);
2786     }
2787 jsr166 1.6
2788 dl 1.5 /**
2789     * runAfterEitherAsync result completes exceptionally if either
2790     * source cancelled
2791     */
2792     public void testRunAfterEitherAsync4E() {
2793 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2794     CompletableFuture<Integer> f2 = new CompletableFuture<>();
2795 dl 1.5 Noop r = new Noop();
2796     CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2797     assertTrue(f.cancel(true));
2798     checkCompletedWithWrappedCancellationException(g);
2799 jsr166 1.6
2800 dl 1.5 r = new Noop();
2801 jsr166 1.22 f = new CompletableFuture<>();
2802     f2 = new CompletableFuture<>();
2803 dl 1.5 assertTrue(f2.cancel(true));
2804     g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2805     checkCompletedWithWrappedCancellationException(g);
2806     }
2807    
2808     /**
2809 jsr166 1.7 * thenComposeAsync result completes normally after normal
2810     * completion of source
2811 dl 1.5 */
2812     public void testThenComposeAsyncE() {
2813 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2814 dl 1.5 CompletableFutureInc r = new CompletableFutureInc();
2815     CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2816     f.complete(one);
2817     checkCompletedNormally(g, two);
2818     }
2819    
2820     /**
2821 jsr166 1.7 * thenComposeAsync result completes exceptionally after
2822     * exceptional completion of source
2823 dl 1.5 */
2824     public void testThenComposeAsync2E() {
2825 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2826 dl 1.5 CompletableFutureInc r = new CompletableFutureInc();
2827     CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2828     f.completeExceptionally(new CFException());
2829     checkCompletedWithWrappedCFException(g);
2830     }
2831    
2832     /**
2833     * thenComposeAsync result completes exceptionally if action does
2834     */
2835     public void testThenComposeAsync3E() {
2836 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2837 dl 1.5 FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
2838     CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2839     f.complete(one);
2840     checkCompletedWithWrappedCFException(g);
2841     }
2842    
2843     /**
2844     * thenComposeAsync result completes exceptionally if source cancelled
2845     */
2846     public void testThenComposeAsync4E() {
2847 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2848 dl 1.5 CompletableFutureInc r = new CompletableFutureInc();
2849     CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2850     assertTrue(f.cancel(true));
2851     checkCompletedWithWrappedCancellationException(g);
2852     }
2853    
2854 jsr166 1.6 // other static methods
2855 dl 1.5
2856     /**
2857     * allOf(no component futures) returns a future completed normally
2858     * with the value null
2859     */
2860     public void testAllOf_empty() throws Exception {
2861 jsr166 1.24 CompletableFuture<Void> f = CompletableFuture.allOf();
2862 dl 1.5 checkCompletedNormally(f, null);
2863     }
2864    
2865     /**
2866 jsr166 1.25 * allOf returns a future completed normally with the value null
2867     * when all components complete normally
2868 dl 1.5 */
2869 jsr166 1.25 public void testAllOf_normal() throws Exception {
2870 dl 1.5 for (int k = 1; k < 20; ++k) {
2871 jsr166 1.22 CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2872 jsr166 1.6 for (int i = 0; i < k; ++i)
2873 jsr166 1.22 fs[i] = new CompletableFuture<>();
2874 dl 1.9 CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2875 dl 1.5 for (int i = 0; i < k; ++i) {
2876     checkIncomplete(f);
2877 jsr166 1.24 checkIncomplete(CompletableFuture.allOf(fs));
2878 dl 1.5 fs[i].complete(one);
2879     }
2880 dl 1.9 checkCompletedNormally(f, null);
2881 jsr166 1.24 checkCompletedNormally(CompletableFuture.allOf(fs), null);
2882 dl 1.5 }
2883     }
2884    
2885     /**
2886     * anyOf(no component futures) returns an incomplete future
2887     */
2888     public void testAnyOf_empty() throws Exception {
2889 jsr166 1.24 CompletableFuture<Object> f = CompletableFuture.anyOf();
2890 dl 1.5 checkIncomplete(f);
2891     }
2892    
2893     /**
2894 jsr166 1.25 * anyOf returns a future completed normally with a value when
2895     * a component future does
2896 dl 1.5 */
2897 jsr166 1.24 public void testAnyOf_normal() throws Exception {
2898     for (int k = 0; k < 10; ++k) {
2899 dl 1.5 CompletableFuture[] fs = new CompletableFuture[k];
2900 jsr166 1.6 for (int i = 0; i < k; ++i)
2901 jsr166 1.22 fs[i] = new CompletableFuture<>();
2902 dl 1.9 CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
2903 dl 1.5 checkIncomplete(f);
2904     for (int i = 0; i < k; ++i) {
2905     fs[i].complete(one);
2906 dl 1.9 checkCompletedNormally(f, one);
2907 jsr166 1.24 checkCompletedNormally(CompletableFuture.anyOf(fs), one);
2908     }
2909     }
2910     }
2911    
2912     /**
2913     * anyOf result completes exceptionally when any component does.
2914     */
2915     public void testAnyOf_exceptional() throws Exception {
2916     for (int k = 0; k < 10; ++k) {
2917     CompletableFuture[] fs = new CompletableFuture[k];
2918     for (int i = 0; i < k; ++i)
2919     fs[i] = new CompletableFuture<>();
2920     CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
2921     checkIncomplete(f);
2922     for (int i = 0; i < k; ++i) {
2923     fs[i].completeExceptionally(new CFException());
2924     checkCompletedWithWrappedCFException(f);
2925     checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
2926 dl 1.5 }
2927     }
2928     }
2929    
2930     /**
2931     * Completion methods throw NullPointerException with null arguments
2932     */
2933     public void testNPE() {
2934 jsr166 1.22 CompletableFuture<Integer> f = new CompletableFuture<>();
2935     CompletableFuture<Integer> g = new CompletableFuture<>();
2936 jsr166 1.14 CompletableFuture<Integer> nullFuture = (CompletableFuture<Integer>)null;
2937     CompletableFuture<?> h;
2938 jsr166 1.17 ThreadExecutor exec = new ThreadExecutor();
2939 jsr166 1.14
2940     Runnable[] throwingActions = {
2941 jsr166 1.31 () -> CompletableFuture.supplyAsync(null),
2942     () -> CompletableFuture.supplyAsync(null, exec),
2943     () -> CompletableFuture.supplyAsync(supplyOne, null),
2944    
2945     () -> CompletableFuture.runAsync(null),
2946     () -> CompletableFuture.runAsync(null, exec),
2947     () -> CompletableFuture.runAsync(() -> {}, null),
2948    
2949     () -> f.completeExceptionally(null),
2950    
2951     () -> f.thenApply(null),
2952     () -> f.thenApplyAsync(null),
2953     () -> f.thenApplyAsync((x) -> x, null),
2954     () -> f.thenApplyAsync(null, exec),
2955    
2956     () -> f.thenAccept(null),
2957     () -> f.thenAcceptAsync(null),
2958     () -> f.thenAcceptAsync((x) -> {} , null),
2959     () -> f.thenAcceptAsync(null, exec),
2960    
2961     () -> f.thenRun(null),
2962     () -> f.thenRunAsync(null),
2963     () -> f.thenRunAsync(() -> {} , null),
2964     () -> f.thenRunAsync(null, exec),
2965    
2966     () -> f.thenCombine(g, null),
2967     () -> f.thenCombineAsync(g, null),
2968     () -> f.thenCombineAsync(g, null, exec),
2969     () -> f.thenCombine(nullFuture, (x, y) -> x),
2970     () -> f.thenCombineAsync(nullFuture, (x, y) -> x),
2971     () -> f.thenCombineAsync(nullFuture, (x, y) -> x, exec),
2972     () -> f.thenCombineAsync(g, (x, y) -> x, null),
2973    
2974     () -> f.thenAcceptBoth(g, null),
2975     () -> f.thenAcceptBothAsync(g, null),
2976     () -> f.thenAcceptBothAsync(g, null, exec),
2977     () -> f.thenAcceptBoth(nullFuture, (x, y) -> {}),
2978     () -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}),
2979     () -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}, exec),
2980     () -> f.thenAcceptBothAsync(g, (x, y) -> {}, null),
2981    
2982     () -> f.runAfterBoth(g, null),
2983     () -> f.runAfterBothAsync(g, null),
2984     () -> f.runAfterBothAsync(g, null, exec),
2985     () -> f.runAfterBoth(nullFuture, () -> {}),
2986     () -> f.runAfterBothAsync(nullFuture, () -> {}),
2987     () -> f.runAfterBothAsync(nullFuture, () -> {}, exec),
2988     () -> f.runAfterBothAsync(g, () -> {}, null),
2989    
2990     () -> f.applyToEither(g, null),
2991     () -> f.applyToEitherAsync(g, null),
2992     () -> f.applyToEitherAsync(g, null, exec),
2993     () -> f.applyToEither(nullFuture, (x) -> x),
2994     () -> f.applyToEitherAsync(nullFuture, (x) -> x),
2995     () -> f.applyToEitherAsync(nullFuture, (x) -> x, exec),
2996     () -> f.applyToEitherAsync(g, (x) -> x, null),
2997    
2998     () -> f.acceptEither(g, null),
2999     () -> f.acceptEitherAsync(g, null),
3000     () -> f.acceptEitherAsync(g, null, exec),
3001     () -> f.acceptEither(nullFuture, (x) -> {}),
3002     () -> f.acceptEitherAsync(nullFuture, (x) -> {}),
3003     () -> f.acceptEitherAsync(nullFuture, (x) -> {}, exec),
3004     () -> f.acceptEitherAsync(g, (x) -> {}, null),
3005    
3006     () -> f.runAfterEither(g, null),
3007     () -> f.runAfterEitherAsync(g, null),
3008     () -> f.runAfterEitherAsync(g, null, exec),
3009     () -> f.runAfterEither(nullFuture, () -> {}),
3010     () -> f.runAfterEitherAsync(nullFuture, () -> {}),
3011     () -> f.runAfterEitherAsync(nullFuture, () -> {}, exec),
3012     () -> f.runAfterEitherAsync(g, () -> {}, null),
3013    
3014     () -> f.thenCompose(null),
3015     () -> f.thenComposeAsync(null),
3016     () -> f.thenComposeAsync(new CompletableFutureInc(), null),
3017     () -> f.thenComposeAsync(null, exec),
3018    
3019     () -> f.exceptionally(null),
3020    
3021     () -> f.handle(null),
3022    
3023     () -> CompletableFuture.allOf((CompletableFuture<?>)null),
3024     () -> CompletableFuture.allOf((CompletableFuture<?>[])null),
3025     () -> CompletableFuture.allOf(f, null),
3026     () -> CompletableFuture.allOf(null, f),
3027    
3028     () -> CompletableFuture.anyOf((CompletableFuture<?>)null),
3029     () -> CompletableFuture.anyOf((CompletableFuture<?>[])null),
3030     () -> CompletableFuture.anyOf(f, null),
3031     () -> CompletableFuture.anyOf(null, f),
3032 jsr166 1.32
3033     () -> f.obtrudeException(null),
3034 jsr166 1.14 };
3035 dl 1.5
3036 jsr166 1.14 assertThrows(NullPointerException.class, throwingActions);
3037 jsr166 1.17 assertEquals(0, exec.count.get());
3038 dl 1.5 }
3039    
3040 dl 1.26 /**
3041     * toCompletableFuture returns this CompletableFuture.
3042     */
3043     public void testToCompletableFuture() {
3044     CompletableFuture<Integer> f = new CompletableFuture<>();
3045     assertSame(f, f.toCompletableFuture());
3046     }
3047    
3048     /**
3049     * whenComplete action executes on normal completion, propagating
3050     * source result.
3051     */
3052     public void testWhenComplete1() {
3053     final AtomicInteger a = new AtomicInteger();
3054     CompletableFuture<Integer> f = new CompletableFuture<>();
3055     CompletableFuture<Integer> g =
3056     f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3057     f.complete(three);
3058     checkCompletedNormally(f, three);
3059     checkCompletedNormally(g, three);
3060     assertEquals(a.get(), 1);
3061     }
3062    
3063     /**
3064     * whenComplete action executes on exceptional completion, propagating
3065     * source result.
3066     */
3067     public void testWhenComplete2() {
3068     final AtomicInteger a = new AtomicInteger();
3069     CompletableFuture<Integer> f = new CompletableFuture<>();
3070     CompletableFuture<Integer> g =
3071     f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3072     f.completeExceptionally(new CFException());
3073     assertTrue(f.isCompletedExceptionally());
3074     assertTrue(g.isCompletedExceptionally());
3075     assertEquals(a.get(), 1);
3076     }
3077    
3078     /**
3079     * If a whenComplete action throws an exception when triggered by
3080     * a normal completion, it completes exceptionally
3081     */
3082     public void testWhenComplete3() {
3083     CompletableFuture<Integer> f = new CompletableFuture<>();
3084     CompletableFuture<Integer> g =
3085     f.whenComplete((Integer x, Throwable t) ->
3086     { throw new CFException(); } );
3087     f.complete(three);
3088     checkCompletedNormally(f, three);
3089     assertTrue(g.isCompletedExceptionally());
3090     checkCompletedWithWrappedCFException(g);
3091     }
3092    
3093     /**
3094     * whenCompleteAsync action executes on normal completion, propagating
3095     * source result.
3096     */
3097     public void testWhenCompleteAsync1() {
3098     final AtomicInteger a = new AtomicInteger();
3099     CompletableFuture<Integer> f = new CompletableFuture<>();
3100     CompletableFuture<Integer> g =
3101     f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3102     f.complete(three);
3103     checkCompletedNormally(f, three);
3104     checkCompletedNormally(g, three);
3105     assertEquals(a.get(), 1);
3106     }
3107    
3108     /**
3109     * whenCompleteAsync action executes on exceptional completion, propagating
3110     * source result.
3111     */
3112     public void testWhenCompleteAsync2() {
3113     final AtomicInteger a = new AtomicInteger();
3114     CompletableFuture<Integer> f = new CompletableFuture<>();
3115     CompletableFuture<Integer> g =
3116     f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3117     f.completeExceptionally(new CFException());
3118     checkCompletedWithWrappedCFException(f);
3119     checkCompletedWithWrappedCFException(g);
3120     }
3121    
3122     /**
3123     * If a whenCompleteAsync action throws an exception when
3124     * triggered by a normal completion, it completes exceptionally
3125     */
3126     public void testWhenCompleteAsync3() {
3127     CompletableFuture<Integer> f = new CompletableFuture<>();
3128     CompletableFuture<Integer> g =
3129     f.whenCompleteAsync((Integer x, Throwable t) ->
3130     { throw new CFException(); } );
3131     f.complete(three);
3132     checkCompletedNormally(f, three);
3133     checkCompletedWithWrappedCFException(g);
3134     }
3135    
3136     /**
3137     * whenCompleteAsync action executes on normal completion, propagating
3138     * source result.
3139     */
3140     public void testWhenCompleteAsync1e() {
3141     final AtomicInteger a = new AtomicInteger();
3142     ThreadExecutor exec = new ThreadExecutor();
3143     CompletableFuture<Integer> f = new CompletableFuture<>();
3144     CompletableFuture<Integer> g =
3145     f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3146     exec);
3147     f.complete(three);
3148     checkCompletedNormally(f, three);
3149     checkCompletedNormally(g, three);
3150     assertEquals(a.get(), 1);
3151     }
3152    
3153     /**
3154     * whenCompleteAsync action executes on exceptional completion, propagating
3155     * source result.
3156     */
3157     public void testWhenCompleteAsync2e() {
3158     final AtomicInteger a = new AtomicInteger();
3159     ThreadExecutor exec = new ThreadExecutor();
3160     CompletableFuture<Integer> f = new CompletableFuture<>();
3161     CompletableFuture<Integer> g =
3162     f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3163     exec);
3164     f.completeExceptionally(new CFException());
3165     checkCompletedWithWrappedCFException(f);
3166     checkCompletedWithWrappedCFException(g);
3167     }
3168    
3169     /**
3170     * If a whenCompleteAsync action throws an exception when triggered
3171     * by a normal completion, it completes exceptionally
3172     */
3173     public void testWhenCompleteAsync3e() {
3174     ThreadExecutor exec = new ThreadExecutor();
3175     CompletableFuture<Integer> f = new CompletableFuture<>();
3176     CompletableFuture<Integer> g =
3177     f.whenCompleteAsync((Integer x, Throwable t) ->
3178     { throw new CFException(); },
3179     exec);
3180     f.complete(three);
3181     checkCompletedNormally(f, three);
3182     checkCompletedWithWrappedCFException(g);
3183     }
3184    
3185     /**
3186 jsr166 1.27 * handleAsync action completes normally with function value on
3187     * either normal or exceptional completion of source
3188 dl 1.26 */
3189     public void testHandleAsync() {
3190     CompletableFuture<Integer> f, g;
3191     IntegerHandler r;
3192    
3193     f = new CompletableFuture<>();
3194     g = f.handleAsync(r = new IntegerHandler());
3195     assertFalse(r.ran);
3196     f.completeExceptionally(new CFException());
3197     checkCompletedWithWrappedCFException(f);
3198     checkCompletedNormally(g, three);
3199     assertTrue(r.ran);
3200    
3201     f = new CompletableFuture<>();
3202     g = f.handleAsync(r = new IntegerHandler());
3203     assertFalse(r.ran);
3204     f.completeExceptionally(new CFException());
3205     checkCompletedWithWrappedCFException(f);
3206     checkCompletedNormally(g, three);
3207     assertTrue(r.ran);
3208    
3209     f = new CompletableFuture<>();
3210     g = f.handleAsync(r = new IntegerHandler());
3211     assertFalse(r.ran);
3212     f.complete(one);
3213     checkCompletedNormally(f, one);
3214     checkCompletedNormally(g, two);
3215     assertTrue(r.ran);
3216    
3217     f = new CompletableFuture<>();
3218     g = f.handleAsync(r = new IntegerHandler());
3219     assertFalse(r.ran);
3220     f.complete(one);
3221     checkCompletedNormally(f, one);
3222     checkCompletedNormally(g, two);
3223     assertTrue(r.ran);
3224     }
3225    
3226     /**
3227     * handleAsync action with Executor completes normally with
3228     * function value on either normal or exceptional completion of
3229     * source
3230     */
3231     public void testHandleAsync2() {
3232     CompletableFuture<Integer> f, g;
3233     ThreadExecutor exec = new ThreadExecutor();
3234     IntegerHandler r;
3235    
3236     f = new CompletableFuture<>();
3237     g = f.handleAsync(r = new IntegerHandler(), exec);
3238     assertFalse(r.ran);
3239     f.completeExceptionally(new CFException());
3240     checkCompletedWithWrappedCFException(f);
3241     checkCompletedNormally(g, three);
3242     assertTrue(r.ran);
3243    
3244     f = new CompletableFuture<>();
3245     g = f.handleAsync(r = new IntegerHandler(), exec);
3246     assertFalse(r.ran);
3247     f.completeExceptionally(new CFException());
3248     checkCompletedWithWrappedCFException(f);
3249     checkCompletedNormally(g, three);
3250     assertTrue(r.ran);
3251    
3252     f = new CompletableFuture<>();
3253     g = f.handleAsync(r = new IntegerHandler(), exec);
3254     assertFalse(r.ran);
3255     f.complete(one);
3256     checkCompletedNormally(f, one);
3257     checkCompletedNormally(g, two);
3258     assertTrue(r.ran);
3259    
3260     f = new CompletableFuture<>();
3261     g = f.handleAsync(r = new IntegerHandler(), exec);
3262     assertFalse(r.ran);
3263     f.complete(one);
3264     checkCompletedNormally(f, one);
3265     checkCompletedNormally(g, two);
3266     assertTrue(r.ran);
3267     }
3268    
3269 jsr166 1.1 }