ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/CompletableFutureTest.java

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.12 by jsr166, Sun Mar 31 18:16:35 2013 UTC vs.
Revision 1.41 by jsr166, Mon Jun 2 01:46:11 2014 UTC

#	Line 16 | Line 16 | import java.util.concurrent.ExecutionExc
16		import java.util.concurrent.Future;
17		import java.util.concurrent.CompletableFuture;
18		import java.util.concurrent.CompletionException;
19	+	import java.util.concurrent.CompletionStage;
20		import java.util.concurrent.TimeoutException;
21		import java.util.concurrent.atomic.AtomicInteger;
22		import static java.util.concurrent.TimeUnit.MILLISECONDS;
#	Line 55 | Line 56 | public class CompletableFutureTest exten
56
57		<T> void checkCompletedNormally(CompletableFuture<T> f, T value) {
58		try {
59	+	assertEquals(value, f.get(LONG_DELAY_MS, MILLISECONDS));
60	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
61	+	try {
62		assertEquals(value, f.join());
63		} catch (Throwable fail) { threadUnexpectedException(fail); }
64		try {
#	Line 63 | Line 67 | public class CompletableFutureTest exten
67		try {
68		assertEquals(value, f.get());
69		} catch (Throwable fail) { threadUnexpectedException(fail); }
66	–	try {
67	–	assertEquals(value, f.get(0L, SECONDS));
68	–	} catch (Throwable fail) { threadUnexpectedException(fail); }
70		assertTrue(f.isDone());
71		assertFalse(f.isCancelled());
72	+	assertFalse(f.isCompletedExceptionally());
73		assertTrue(f.toString().contains("[Completed normally]"));
74		}
75
76		void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
77		try {
78	+	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		f.join();
85		shouldThrow();
86		} catch (CompletionException success) {
#	Line 90 | Line 98 | public class CompletableFutureTest exten
98		} catch (ExecutionException success) {
99		assertTrue(success.getCause() instanceof CFException);
100		} catch (Throwable fail) { threadUnexpectedException(fail); }
101	+	assertTrue(f.isDone());
102	+	assertFalse(f.isCancelled());
103	+	assertTrue(f.toString().contains("[Completed exceptionally]"));
104	+	}
105	+
106	+	void checkCompletedWithWrappedCFException(CompletableFuture<?> f,
107	+	CFException ex) {
108		try {
109	<	f.get(0L, SECONDS);
109	>	f.get(LONG_DELAY_MS, MILLISECONDS);
110		shouldThrow();
111		} catch (ExecutionException success) {
112	<	assertTrue(success.getCause() instanceof CFException);
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		void checkCancelled(CompletableFuture<?> f) {
138		try {
139	+	f.get(LONG_DELAY_MS, MILLISECONDS);
140	+	shouldThrow();
141	+	} catch (CancellationException success) {
142	+	} catch (Throwable fail) { threadUnexpectedException(fail); }
143	+	try {
144		f.join();
145		shouldThrow();
146		} catch (CancellationException success) {}
#	Line 114 | Line 153 | public class CompletableFutureTest exten
153		shouldThrow();
154		} catch (CancellationException success) {
155		} catch (Throwable fail) { threadUnexpectedException(fail); }
117	–	try {
118	–	f.get(0L, SECONDS);
119	–	shouldThrow();
120	–	} catch (CancellationException success) {
121	–	} catch (Throwable fail) { threadUnexpectedException(fail); }
156		assertTrue(f.isDone());
157	+	assertTrue(f.isCompletedExceptionally());
158		assertTrue(f.isCancelled());
159	+	assertTrue(f.toString().contains("[Completed exceptionally]"));
160		}
161
162		void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
163		try {
164	+	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		f.join();
171		shouldThrow();
172		} catch (CompletionException success) {
#	Line 142 | Line 184 | public class CompletableFutureTest exten
184		} catch (ExecutionException success) {
185		assertTrue(success.getCause() instanceof CancellationException);
186		} catch (Throwable fail) { threadUnexpectedException(fail); }
145	–	try {
146	–	f.get(0L, SECONDS);
147	–	shouldThrow();
148	–	} catch (ExecutionException success) {
149	–	assertTrue(success.getCause() instanceof CancellationException);
150	–	} catch (Throwable fail) { threadUnexpectedException(fail); }
187		assertTrue(f.isDone());
188		assertFalse(f.isCancelled());
189	+	assertTrue(f.isCompletedExceptionally());
190	+	assertTrue(f.toString().contains("[Completed exceptionally]"));
191		}
192
193		/**
#	Line 157 | Line 195 | public class CompletableFutureTest exten
195		* by methods isDone, isCancelled, and getNow
196		*/
197		public void testConstructor() {
198	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
198	>	CompletableFuture<Integer> f = new CompletableFuture<>();
199		checkIncomplete(f);
200		}
201
#	Line 166 | Line 204 | public class CompletableFutureTest exten
204		* isCancelled, join, get, and getNow
205		*/
206		public void testComplete() {
207	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
207	>	CompletableFuture<Integer> f = new CompletableFuture<>();
208		checkIncomplete(f);
209		f.complete(one);
210		checkCompletedNormally(f, one);
#	Line 177 | Line 215 | public class CompletableFutureTest exten
215		* methods isDone, isCancelled, join, get, and getNow
216		*/
217		public void testCompleteExceptionally() {
218	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
218	>	CompletableFuture<Integer> f = new CompletableFuture<>();
219		checkIncomplete(f);
220		f.completeExceptionally(new CFException());
221		checkCompletedWithWrappedCFException(f);
#	Line 188 | Line 226 | public class CompletableFutureTest exten
226		* methods isDone, isCancelled, join, get, and getNow
227		*/
228		public void testCancel() {
229	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
229	>	CompletableFuture<Integer> f = new CompletableFuture<>();
230		checkIncomplete(f);
231		assertTrue(f.cancel(true));
232		checkCancelled(f);
#	Line 198 | Line 236 | public class CompletableFutureTest exten
236		* obtrudeValue forces completion with given value
237		*/
238		public void testObtrudeValue() {
239	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
239	>	CompletableFuture<Integer> f = new CompletableFuture<>();
240		checkIncomplete(f);
241		f.complete(one);
242		checkCompletedNormally(f, one);
#	Line 206 | Line 244 | public class CompletableFutureTest exten
244		checkCompletedNormally(f, three);
245		f.obtrudeValue(two);
246		checkCompletedNormally(f, two);
247	<	f = new CompletableFuture<Integer>();
247	>	f = new CompletableFuture<>();
248		f.obtrudeValue(three);
249		checkCompletedNormally(f, three);
250	<	f = new CompletableFuture<Integer>();
250	>	f = new CompletableFuture<>();
251		f.completeExceptionally(new CFException());
252		f.obtrudeValue(four);
253		checkCompletedNormally(f, four);
#	Line 219 | Line 257 | public class CompletableFutureTest exten
257		* obtrudeException forces completion with given exception
258		*/
259		public void testObtrudeException() {
260	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
260	>	CompletableFuture<Integer> f = new CompletableFuture<>();
261		checkIncomplete(f);
262		f.complete(one);
263		checkCompletedNormally(f, one);
264		f.obtrudeException(new CFException());
265		checkCompletedWithWrappedCFException(f);
266	<	f = new CompletableFuture<Integer>();
266	>	f = new CompletableFuture<>();
267		f.obtrudeException(new CFException());
268		checkCompletedWithWrappedCFException(f);
269	<	f = new CompletableFuture<Integer>();
269	>	f = new CompletableFuture<>();
270		f.completeExceptionally(new CFException());
271		f.obtrudeValue(four);
272		checkCompletedNormally(f, four);
#	Line 240 | Line 278 | public class CompletableFutureTest exten
278		* getNumberOfDependents returns number of dependent tasks
279		*/
280		public void testGetNumberOfDependents() {
281	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
281	>	CompletableFuture<Integer> f = new CompletableFuture<>();
282		assertEquals(f.getNumberOfDependents(), 0);
283		CompletableFuture g = f.thenRun(new Noop());
284		assertEquals(f.getNumberOfDependents(), 1);
#	Line 253 | Line 291 | public class CompletableFutureTest exten
291		assertEquals(g.getNumberOfDependents(), 0);
292		}
293
256	–
294		/**
295		* toString indicates current completion state
296		*/
#	Line 279 | Line 316 | public class CompletableFutureTest exten
316		checkCompletedNormally(f, "test");
317		}
318
319	+	// Choose non-commutative actions for better coverage
320	+
321	+	// A non-commutative function that handles and produces null values as well.
322	+	static Integer subtract(Integer x, Integer y) {
323	+	return (x == null && y == null) ? null :
324	+	((x == null) ? 42 : x.intValue())
325	+	- ((y == null) ? 99 : y.intValue());
326	+	}
327	+
328	+	// A function that handles and produces null values as well.
329	+	static Integer inc(Integer x) {
330	+	return (x == null) ? null : x + 1;
331	+	}
332	+
333		static final Supplier<Integer> supplyOne =
334		() -> Integer.valueOf(1);
335		static final Function<Integer, Integer> inc =
336		(Integer x) -> Integer.valueOf(x.intValue() + 1);
337	<	static final BiFunction<Integer, Integer, Integer> add =
338	<	(Integer x, Integer y) -> Integer.valueOf(x.intValue() + y.intValue());
337	>	static final BiFunction<Integer, Integer, Integer> subtract =
338	>	(Integer x, Integer y) -> subtract(x, y);
339		static final class IncAction implements Consumer<Integer> {
340	<	int value;
341	<	public void accept(Integer x) { value = x.intValue() + 1; }
340	>	int invocationCount = 0;
341	>	Integer value;
342	>	public boolean ran() { return invocationCount == 1; }
343	>	public void accept(Integer x) {
344	>	invocationCount++;
345	>	value = inc(x);
346	>	}
347		}
348	<	static final class AddAction implements BiConsumer<Integer, Integer> {
349	<	int value;
348	>	static final class IncFunction implements Function<Integer,Integer> {
349	>	int invocationCount = 0;
350	>	Integer value;
351	>	public boolean ran() { return invocationCount == 1; }
352	>	public Integer apply(Integer x) {
353	>	invocationCount++;
354	>	return value = inc(x);
355	>	}
356	>	}
357	>	static final class SubtractAction implements BiConsumer<Integer, Integer> {
358	>	int invocationCount = 0;
359	>	Integer value;
360	>	// Check this action was invoked exactly once when result is computed.
361	>	public boolean ran() { return invocationCount == 1; }
362		public void accept(Integer x, Integer y) {
363	<	value = x.intValue() + y.intValue();
363	>	invocationCount++;
364	>	value = subtract(x, y);
365	>	}
366	>	}
367	>	static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
368	>	int invocationCount = 0;
369	>	Integer value;
370	>	// Check this action was invoked exactly once when result is computed.
371	>	public boolean ran() { return invocationCount == 1; }
372	>	public Integer apply(Integer x, Integer y) {
373	>	invocationCount++;
374	>	return value = subtract(x, y);
375		}
376		}
377		static final class Noop implements Runnable {
378	+	int invocationCount = 0;
379		boolean ran;
380	<	public void run() { ran = true; }
380	>	public void run() {
381	>	invocationCount++;
382	>	ran = true;
383	>	}
384		}
385
386		static final class FailingSupplier implements Supplier<Integer> {
#	Line 325 | Line 408 | public class CompletableFutureTest exten
408		public void run() { ran = true; throw new CFException(); }
409		}
410
411	<	static final class CompletableFutureInc implements Function<Integer, CompletableFuture<Integer>> {
411	>	static final class CompletableFutureInc
412	>	implements Function<Integer, CompletableFuture<Integer>> {
413	>	boolean ran;
414		public CompletableFuture<Integer> apply(Integer x) {
415	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
415	>	ran = true;
416	>	CompletableFuture<Integer> f = new CompletableFuture<>();
417		f.complete(Integer.valueOf(x.intValue() + 1));
418		return f;
419		}
420		}
421
422	<	static final class FailingCompletableFutureFunction implements Function<Integer, CompletableFuture<Integer>> {
422	>	static final class FailingCompletableFutureFunction
423	>	implements Function<Integer, CompletableFuture<Integer>> {
424		boolean ran;
425		public CompletableFuture<Integer> apply(Integer x) {
426		ran = true; throw new CFException();
#	Line 342 | Line 429 | public class CompletableFutureTest exten
429
430		// Used for explicit executor tests
431		static final class ThreadExecutor implements Executor {
432	+	AtomicInteger count = new AtomicInteger(0);
433	+
434		public void execute(Runnable r) {
435	+	count.getAndIncrement();
436		new Thread(r).start();
437		}
438		}
#	Line 352 | Line 442 | public class CompletableFutureTest exten
442		}
443
444		static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
445	+	boolean ran;
446		public Integer apply(Integer x, Throwable t) {
447	+	ran = true;
448		return (t == null) ? two : three;
449		}
450		}
451
452	+	/**
453	+	* Permits the testing of parallel code for the 3 different
454	+	* execution modes without repeating all the testing code.
455	+	*/
456	+	enum ExecutionMode {
457	+	DEFAULT {
458	+	public <T,U> CompletableFuture<Void> runAfterBoth
459	+	(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
460	+	return f.runAfterBoth(g, a);
461	+	}
462	+	public <T,U> CompletableFuture<Void> thenAcceptBoth
463	+	(CompletableFuture<T> f,
464	+	CompletionStage<? extends U> g,
465	+	BiConsumer<? super T,? super U> a) {
466	+	return f.thenAcceptBoth(g, a);
467	+	}
468	+	public <T,U,V> CompletableFuture<V> thenCombine
469	+	(CompletableFuture<T> f,
470	+	CompletionStage<? extends U> g,
471	+	BiFunction<? super T,? super U,? extends V> a) {
472	+	return f.thenCombine(g, a);
473	+	}
474	+	public <T,U> CompletableFuture<U> applyToEither
475	+	(CompletableFuture<T> f,
476	+	CompletionStage<? extends T> g,
477	+	Function<? super T,U> a) {
478	+	return f.applyToEither(g, a);
479	+	}
480	+	public <T> CompletableFuture<Void> acceptEither
481	+	(CompletableFuture<T> f,
482	+	CompletionStage<? extends T> g,
483	+	Consumer<? super T> a) {
484	+	return f.acceptEither(g, a);
485	+	}
486	+	public <T> CompletableFuture<Void> runAfterEither
487	+	(CompletableFuture<T> f,
488	+	CompletionStage<?> g,
489	+	java.lang.Runnable a) {
490	+	return f.runAfterEither(g, a);
491	+	}
492	+	public <T,U> CompletableFuture<U> thenCompose
493	+	(CompletableFuture<T> f,
494	+	Function<? super T,? extends CompletionStage<U>> a) {
495	+	return f.thenCompose(a);
496	+	}
497	+	public <T> CompletableFuture<T> whenComplete
498	+	(CompletableFuture<T> f,
499	+	BiConsumer<? super T,? super Throwable> a) {
500	+	return f.whenComplete(a);
501	+	}
502	+	},
503	+
504	+	//             /** Experimental way to do more testing */
505	+	//         REVERSE_DEFAULT {
506	+	//             public <T,U> CompletableFuture<Void> runAfterBoth
507	+	//                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
508	+	//                 return g.runAfterBoth(f, a);
509	+	//             }
510	+	//             public <T,U> CompletableFuture<Void> thenAcceptBoth
511	+	//                 (CompletableFuture<T> f,
512	+	//                  CompletionStage<? extends U> g,
513	+	//                  BiConsumer<? super T,? super U> a) {
514	+	//                 return DEFAULT.thenAcceptBoth(f, g, a);
515	+	//             }
516	+	//         },
517	+
518	+	DEFAULT_ASYNC {
519	+	public <T,U> CompletableFuture<Void> runAfterBoth
520	+	(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
521	+	return f.runAfterBothAsync(g, a);
522	+	}
523	+	public <T,U> CompletableFuture<Void> thenAcceptBoth
524	+	(CompletableFuture<T> f,
525	+	CompletionStage<? extends U> g,
526	+	BiConsumer<? super T,? super U> a) {
527	+	return f.thenAcceptBothAsync(g, a);
528	+	}
529	+	public <T,U,V> CompletableFuture<V> thenCombine
530	+	(CompletableFuture<T> f,
531	+	CompletionStage<? extends U> g,
532	+	BiFunction<? super T,? super U,? extends V> a) {
533	+	return f.thenCombineAsync(g, a);
534	+	}
535	+	public <T,U> CompletableFuture<U> applyToEither
536	+	(CompletableFuture<T> f,
537	+	CompletionStage<? extends T> g,
538	+	Function<? super T,U> a) {
539	+	return f.applyToEitherAsync(g, a);
540	+	}
541	+	public <T> CompletableFuture<Void> acceptEither
542	+	(CompletableFuture<T> f,
543	+	CompletionStage<? extends T> g,
544	+	Consumer<? super T> a) {
545	+	return f.acceptEitherAsync(g, a);
546	+	}
547	+	public <T> CompletableFuture<Void> runAfterEither
548	+	(CompletableFuture<T> f,
549	+	CompletionStage<?> g,
550	+	java.lang.Runnable a) {
551	+	return f.runAfterEitherAsync(g, a);
552	+	}
553	+	public <T,U> CompletableFuture<U> thenCompose
554	+	(CompletableFuture<T> f,
555	+	Function<? super T,? extends CompletionStage<U>> a) {
556	+	return f.thenComposeAsync(a);
557	+	}
558	+	public <T> CompletableFuture<T> whenComplete
559	+	(CompletableFuture<T> f,
560	+	BiConsumer<? super T,? super Throwable> a) {
561	+	return f.whenCompleteAsync(a);
562	+	}
563	+	},
564	+
565	+	//         REVERSE_DEFAULT_ASYNC {
566	+	//             public <T,U> CompletableFuture<Void> runAfterBoth
567	+	//                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
568	+	//                 return f.runAfterBothAsync(g, a);
569	+	//             }
570	+	//             public <T,U> CompletableFuture<Void> thenAcceptBoth
571	+	//                 (CompletableFuture<T> f,
572	+	//                  CompletionStage<? extends U> g,
573	+	//                  BiConsumer<? super T,? super U> a) {
574	+	//                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
575	+	//             }
576	+	//         },
577	+
578	+	EXECUTOR {
579	+	public <T,U> CompletableFuture<Void> runAfterBoth
580	+	(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
581	+	return f.runAfterBothAsync(g, a, new ThreadExecutor());
582	+	}
583	+	public <T,U> CompletableFuture<Void> thenAcceptBoth
584	+	(CompletableFuture<T> f,
585	+	CompletionStage<? extends U> g,
586	+	BiConsumer<? super T,? super U> a) {
587	+	return f.thenAcceptBothAsync(g, a, new ThreadExecutor());
588	+	}
589	+	public <T,U,V> CompletableFuture<V> thenCombine
590	+	(CompletableFuture<T> f,
591	+	CompletionStage<? extends U> g,
592	+	BiFunction<? super T,? super U,? extends V> a) {
593	+	return f.thenCombineAsync(g, a, new ThreadExecutor());
594	+	}
595	+	public <T,U> CompletableFuture<U> applyToEither
596	+	(CompletableFuture<T> f,
597	+	CompletionStage<? extends T> g,
598	+	Function<? super T,U> a) {
599	+	return f.applyToEitherAsync(g, a, new ThreadExecutor());
600	+	}
601	+	public <T> CompletableFuture<Void> acceptEither
602	+	(CompletableFuture<T> f,
603	+	CompletionStage<? extends T> g,
604	+	Consumer<? super T> a) {
605	+	return f.acceptEitherAsync(g, a, new ThreadExecutor());
606	+	}
607	+	public <T> CompletableFuture<Void> runAfterEither
608	+	(CompletableFuture<T> f,
609	+	CompletionStage<?> g,
610	+	java.lang.Runnable a) {
611	+	return f.runAfterEitherAsync(g, a, new ThreadExecutor());
612	+	}
613	+	public <T,U> CompletableFuture<U> thenCompose
614	+	(CompletableFuture<T> f,
615	+	Function<? super T,? extends CompletionStage<U>> a) {
616	+	return f.thenComposeAsync(a, new ThreadExecutor());
617	+	}
618	+	public <T> CompletableFuture<T> whenComplete
619	+	(CompletableFuture<T> f,
620	+	BiConsumer<? super T,? super Throwable> a) {
621	+	return f.whenCompleteAsync(a, new ThreadExecutor());
622	+	}
623	+	};
624	+
625	+	public abstract <T,U> CompletableFuture<Void> runAfterBoth
626	+	(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
627	+	public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
628	+	(CompletableFuture<T> f,
629	+	CompletionStage<? extends U> g,
630	+	BiConsumer<? super T,? super U> a);
631	+	public abstract <T,U,V> CompletableFuture<V> thenCombine
632	+	(CompletableFuture<T> f,
633	+	CompletionStage<? extends U> g,
634	+	BiFunction<? super T,? super U,? extends V> a);
635	+	public abstract <T,U> CompletableFuture<U> applyToEither
636	+	(CompletableFuture<T> f,
637	+	CompletionStage<? extends T> g,
638	+	Function<? super T,U> a);
639	+	public abstract <T> CompletableFuture<Void> acceptEither
640	+	(CompletableFuture<T> f,
641	+	CompletionStage<? extends T> g,
642	+	Consumer<? super T> a);
643	+	public abstract <T> CompletableFuture<Void> runAfterEither
644	+	(CompletableFuture<T> f,
645	+	CompletionStage<?> g,
646	+	java.lang.Runnable a);
647	+	public abstract <T,U> CompletableFuture<U> thenCompose
648	+	(CompletableFuture<T> f,
649	+	Function<? super T,? extends CompletionStage<U>> a);
650	+	public abstract <T> CompletableFuture<T> whenComplete
651	+	(CompletableFuture<T> f,
652	+	BiConsumer<? super T,? super Throwable> a);
653	+
654	+
655	+	}
656
657		/**
658		* exceptionally action completes with function value on source
659	<	* exception;  otherwise with source value
659	>	* exception; otherwise with source value
660		*/
661		public void testExceptionally() {
662	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
662	>	CompletableFuture<Integer> f = new CompletableFuture<>();
663		ExceptionToInteger r = new ExceptionToInteger();
664		CompletableFuture<Integer> g = f.exceptionally(r);
665		f.completeExceptionally(new CFException());
666		checkCompletedNormally(g, three);
667
668	<	f = new CompletableFuture<Integer>();
668	>	f = new CompletableFuture<>();
669		r = new ExceptionToInteger();
670		g = f.exceptionally(r);
671		f.complete(one);
#	Line 381 | Line 677 | public class CompletableFutureTest exten
677		* normal or exceptional completion of source
678		*/
679		public void testHandle() {
680	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
681	<	IntegerHandler r = new IntegerHandler();
682	<	CompletableFuture<Integer> g = f.handle(r);
680	>	CompletableFuture<Integer> f, g;
681	>	IntegerHandler r;
682	>
683	>	f = new CompletableFuture<>();
684	>	f.completeExceptionally(new CFException());
685	>	g = f.handle(r = new IntegerHandler());
686	>	assertTrue(r.ran);
687	>	checkCompletedNormally(g, three);
688	>
689	>	f = new CompletableFuture<>();
690	>	g = f.handle(r = new IntegerHandler());
691	>	assertFalse(r.ran);
692		f.completeExceptionally(new CFException());
693		checkCompletedNormally(g, three);
694	+	assertTrue(r.ran);
695	+
696	+	f = new CompletableFuture<>();
697	+	f.complete(one);
698	+	g = f.handle(r = new IntegerHandler());
699	+	assertTrue(r.ran);
700	+	checkCompletedNormally(g, two);
701
702	<	f = new CompletableFuture<Integer>();
703	<	r = new IntegerHandler();
704	<	g = f.handle(r);
702	>	f = new CompletableFuture<>();
703	>	g = f.handle(r = new IntegerHandler());
704	>	assertFalse(r.ran);
705		f.complete(one);
706	+	assertTrue(r.ran);
707		checkCompletedNormally(g, two);
708		}
709
#	Line 402 | Line 715 | public class CompletableFutureTest exten
715		CompletableFuture<Void> f = CompletableFuture.runAsync(r);
716		assertNull(f.join());
717		assertTrue(r.ran);
718	+	checkCompletedNormally(f, null);
719		}
720
721		/**
#	Line 409 | Line 723 | public class CompletableFutureTest exten
723		*/
724		public void testRunAsync2() {
725		Noop r = new Noop();
726	<	CompletableFuture<Void> f = CompletableFuture.runAsync(r, new ThreadExecutor());
726	>	ThreadExecutor exec = new ThreadExecutor();
727	>	CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
728		assertNull(f.join());
729		assertTrue(r.ran);
730	+	checkCompletedNormally(f, null);
731	+	assertEquals(1, exec.count.get());
732		}
733
734		/**
#	Line 428 | Line 745 | public class CompletableFutureTest exten
745		* supplyAsync completes with result of supplier
746		*/
747		public void testSupplyAsync() {
748	<	CompletableFuture<Integer> f = CompletableFuture.supplyAsync(supplyOne);
748	>	CompletableFuture<Integer> f;
749	>	f = CompletableFuture.supplyAsync(supplyOne);
750		assertEquals(f.join(), one);
751	+	checkCompletedNormally(f, one);
752		}
753
754		/**
755		* supplyAsync with executor completes with result of supplier
756		*/
757		public void testSupplyAsync2() {
758	<	CompletableFuture<Integer> f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
758	>	CompletableFuture<Integer> f;
759	>	f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
760		assertEquals(f.join(), one);
761	+	checkCompletedNormally(f, one);
762		}
763
764		/**
#	Line 456 | Line 777 | public class CompletableFutureTest exten
777		* thenRun result completes normally after normal completion of source
778		*/
779		public void testThenRun() {
780	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
781	<	Noop r = new Noop();
782	<	CompletableFuture<Void> g = f.thenRun(r);
780	>	CompletableFuture<Integer> f;
781	>	CompletableFuture<Void> g;
782	>	Noop r;
783	>
784	>	f = new CompletableFuture<>();
785	>	g = f.thenRun(r = new Noop());
786		f.complete(null);
787		checkCompletedNormally(g, null);
788	<	// reordered version
789	<	f = new CompletableFuture<Integer>();
788	>	assertTrue(r.ran);
789	>
790	>	f = new CompletableFuture<>();
791		f.complete(null);
792	<	r = new Noop();
468	<	g = f.thenRun(r);
792	>	g = f.thenRun(r = new Noop());
793		checkCompletedNormally(g, null);
794	+	assertTrue(r.ran);
795		}
796
797		/**
#	Line 474 | Line 799 | public class CompletableFutureTest exten
799		* completion of source
800		*/
801		public void testThenRun2() {
802	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
803	<	Noop r = new Noop();
804	<	CompletableFuture<Void> g = f.thenRun(r);
802	>	CompletableFuture<Integer> f;
803	>	CompletableFuture<Void> g;
804	>	Noop r;
805	>
806	>	f = new CompletableFuture<>();
807	>	g = f.thenRun(r = new Noop());
808	>	f.completeExceptionally(new CFException());
809	>	checkCompletedWithWrappedCFException(g);
810	>	assertFalse(r.ran);
811	>
812	>	f = new CompletableFuture<>();
813		f.completeExceptionally(new CFException());
814	+	g = f.thenRun(r = new Noop());
815		checkCompletedWithWrappedCFException(g);
816	+	assertFalse(r.ran);
817		}
818
819		/**
820		* thenRun result completes exceptionally if action does
821		*/
822		public void testThenRun3() {
823	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
824	<	FailingNoop r = new FailingNoop();
825	<	CompletableFuture<Void> g = f.thenRun(r);
823	>	CompletableFuture<Integer> f;
824	>	CompletableFuture<Void> g;
825	>	FailingNoop r;
826	>
827	>	f = new CompletableFuture<>();
828	>	g = f.thenRun(r = new FailingNoop());
829		f.complete(null);
830		checkCompletedWithWrappedCFException(g);
831	+
832	+	f = new CompletableFuture<>();
833	+	f.complete(null);
834	+	g = f.thenRun(r = new FailingNoop());
835	+	checkCompletedWithWrappedCFException(g);
836		}
837
838		/**
839		* thenRun result completes exceptionally if source cancelled
840		*/
841		public void testThenRun4() {
842	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
843	<	Noop r = new Noop();
844	<	CompletableFuture<Void> g = f.thenRun(r);
842	>	CompletableFuture<Integer> f;
843	>	CompletableFuture<Void> g;
844	>	Noop r;
845	>
846	>	f = new CompletableFuture<>();
847	>	g = f.thenRun(r = new Noop());
848		assertTrue(f.cancel(true));
849		checkCompletedWithWrappedCancellationException(g);
850	+
851	+	f = new CompletableFuture<>();
852	+	assertTrue(f.cancel(true));
853	+	g = f.thenRun(r = new Noop());
854	+	checkCompletedWithWrappedCancellationException(g);
855		}
856
857		/**
858		* thenApply result completes normally after normal completion of source
859		*/
860		public void testThenApply() {
861	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
861	>	CompletableFuture<Integer> f = new CompletableFuture<>();
862		CompletableFuture<Integer> g = f.thenApply(inc);
863		f.complete(one);
864		checkCompletedNormally(g, two);
#	Line 518 | Line 869 | public class CompletableFutureTest exten
869		* completion of source
870		*/
871		public void testThenApply2() {
872	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
872	>	CompletableFuture<Integer> f = new CompletableFuture<>();
873		CompletableFuture<Integer> g = f.thenApply(inc);
874		f.completeExceptionally(new CFException());
875		checkCompletedWithWrappedCFException(g);
#	Line 528 | Line 879 | public class CompletableFutureTest exten
879		* thenApply result completes exceptionally if action does
880		*/
881		public void testThenApply3() {
882	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
882	>	CompletableFuture<Integer> f = new CompletableFuture<>();
883		CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
884		f.complete(one);
885		checkCompletedWithWrappedCFException(g);
#	Line 538 | Line 889 | public class CompletableFutureTest exten
889		* thenApply result completes exceptionally if source cancelled
890		*/
891		public void testThenApply4() {
892	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
892	>	CompletableFuture<Integer> f = new CompletableFuture<>();
893		CompletableFuture<Integer> g = f.thenApply(inc);
894		assertTrue(f.cancel(true));
895		checkCompletedWithWrappedCancellationException(g);
#	Line 548 | Line 899 | public class CompletableFutureTest exten
899		* thenAccept result completes normally after normal completion of source
900		*/
901		public void testThenAccept() {
902	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
902	>	CompletableFuture<Integer> f = new CompletableFuture<>();
903		IncAction r = new IncAction();
904		CompletableFuture<Void> g = f.thenAccept(r);
905		f.complete(one);
906		checkCompletedNormally(g, null);
907	<	assertEquals(r.value, 2);
907	>	assertEquals(r.value, (Integer) 2);
908		}
909
910		/**
#	Line 561 | Line 912 | public class CompletableFutureTest exten
912		* completion of source
913		*/
914		public void testThenAccept2() {
915	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
915	>	CompletableFuture<Integer> f = new CompletableFuture<>();
916		IncAction r = new IncAction();
917		CompletableFuture<Void> g = f.thenAccept(r);
918		f.completeExceptionally(new CFException());
#	Line 572 | Line 923 | public class CompletableFutureTest exten
923		* thenAccept result completes exceptionally if action does
924		*/
925		public void testThenAccept3() {
926	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
926	>	CompletableFuture<Integer> f = new CompletableFuture<>();
927		FailingConsumer r = new FailingConsumer();
928		CompletableFuture<Void> g = f.thenAccept(r);
929		f.complete(one);
#	Line 584 | Line 935 | public class CompletableFutureTest exten
935		* thenAccept result completes exceptionally if source cancelled
936		*/
937		public void testThenAccept4() {
938	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
938	>	CompletableFuture<Integer> f = new CompletableFuture<>();
939		IncAction r = new IncAction();
940		CompletableFuture<Void> g = f.thenAccept(r);
941		assertTrue(f.cancel(true));
942		checkCompletedWithWrappedCancellationException(g);
943		}
944
594	–
945		/**
946	<	* thenCombine result completes normally after normal completion of sources
946	>	* thenCombine result completes normally after normal completion
947	>	* of sources
948		*/
949	<	public void testThenCombine() {
950	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
951	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
952	<	CompletableFuture<Integer> g = f.thenCombine(f2, add);
953	<	f.complete(one);
954	<	checkIncomplete(g);
955	<	f2.complete(two);
956	<	checkCompletedNormally(g, three);
949	>	public void testThenCombine_normalCompletion1() {
950	>	for (ExecutionMode m : ExecutionMode.values())
951	>	for (Integer v1 : new Integer[] { 1, null })
952	>	for (Integer v2 : new Integer[] { 2, null }) {
953	>
954	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
955	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
956	>	final SubtractFunction r = new SubtractFunction();
957	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
958	>
959	>	f.complete(v1);
960	>	checkIncomplete(h);
961	>	assertEquals(r.invocationCount, 0);
962	>	g.complete(v2);
963	>
964	>	checkCompletedNormally(h, subtract(v1, v2));
965	>	checkCompletedNormally(f, v1);
966	>	checkCompletedNormally(g, v2);
967	>	assertEquals(r.invocationCount, 1);
968	>	}
969	>	}
970
971	<	f = new CompletableFuture<Integer>();
972	<	f.complete(one);
973	<	f2 = new CompletableFuture<Integer>();
974	<	g = f.thenCombine(f2, add);
975	<	checkIncomplete(g);
976	<	f2.complete(two);
977	<	checkCompletedNormally(g, three);
971	>	public void testThenCombine_normalCompletion2() {
972	>	for (ExecutionMode m : ExecutionMode.values())
973	>	for (Integer v1 : new Integer[] { 1, null })
974	>	for (Integer v2 : new Integer[] { 2, null }) {
975	>
976	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
977	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
978	>	final SubtractFunction r = new SubtractFunction();
979	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
980	>
981	>	g.complete(v2);
982	>	checkIncomplete(h);
983	>	assertEquals(r.invocationCount, 0);
984	>	f.complete(v1);
985	>
986	>	checkCompletedNormally(h, subtract(v1, v2));
987	>	checkCompletedNormally(f, v1);
988	>	checkCompletedNormally(g, v2);
989	>	assertEquals(r.invocationCount, 1);
990	>	}
991	>	}
992	>
993	>	public void testThenCombine_normalCompletion3() {
994	>	for (ExecutionMode m : ExecutionMode.values())
995	>	for (Integer v1 : new Integer[] { 1, null })
996	>	for (Integer v2 : new Integer[] { 2, null }) {
997	>
998	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
999	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1000	>	final SubtractFunction r = new SubtractFunction();
1001	>
1002	>	g.complete(v2);
1003	>	f.complete(v1);
1004	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1005	>
1006	>	checkCompletedNormally(h, subtract(v1, v2));
1007	>	checkCompletedNormally(f, v1);
1008	>	checkCompletedNormally(g, v2);
1009	>	assertEquals(r.invocationCount, 1);
1010	>	}
1011	>	}
1012	>
1013	>	public void testThenCombine_normalCompletion4() {
1014	>	for (ExecutionMode m : ExecutionMode.values())
1015	>	for (Integer v1 : new Integer[] { 1, null })
1016	>	for (Integer v2 : new Integer[] { 2, null }) {
1017	>
1018	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1019	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1020	>	final SubtractFunction r = new SubtractFunction();
1021	>
1022	>	f.complete(v1);
1023	>	g.complete(v2);
1024	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1025	>
1026	>	checkCompletedNormally(h, subtract(v1, v2));
1027	>	checkCompletedNormally(f, v1);
1028	>	checkCompletedNormally(g, v2);
1029	>	assertEquals(r.invocationCount, 1);
1030	>	}
1031		}
1032
1033		/**
1034		* thenCombine result completes exceptionally after exceptional
1035		* completion of either source
1036		*/
1037	<	public void testThenCombine2() {
1038	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1039	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1040	<	CompletableFuture<Integer> g = f.thenCombine(f2, add);
1041	<	f.completeExceptionally(new CFException());
1042	<	f2.complete(two);
1043	<	checkCompletedWithWrappedCFException(g);
1037	>	public void testThenCombine_exceptionalCompletion1() {
1038	>	for (ExecutionMode m : ExecutionMode.values())
1039	>	for (Integer v1 : new Integer[] { 1, null }) {
1040	>
1041	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1042	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1043	>	final SubtractFunction r = new SubtractFunction();
1044	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1045	>	final CFException ex = new CFException();
1046	>
1047	>	f.completeExceptionally(ex);
1048	>	checkIncomplete(h);
1049	>	g.complete(v1);
1050	>
1051	>	checkCompletedWithWrappedCFException(h, ex);
1052	>	checkCompletedWithWrappedCFException(f, ex);
1053	>	assertEquals(r.invocationCount, 0);
1054	>	checkCompletedNormally(g, v1);
1055	>	}
1056	>	}
1057
1058	<	f = new CompletableFuture<Integer>();
1059	<	f.complete(one);
1060	<	f2 = new CompletableFuture<Integer>();
1061	<	g = f.thenCombine(f2, add);
1062	<	f2.completeExceptionally(new CFException());
1063	<	checkCompletedWithWrappedCFException(g);
1058	>	public void testThenCombine_exceptionalCompletion2() {
1059	>	for (ExecutionMode m : ExecutionMode.values())
1060	>	for (Integer v1 : new Integer[] { 1, null }) {
1061	>
1062	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1063	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1064	>	final SubtractFunction r = new SubtractFunction();
1065	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1066	>	final CFException ex = new CFException();
1067	>
1068	>	g.completeExceptionally(ex);
1069	>	checkIncomplete(h);
1070	>	f.complete(v1);
1071	>
1072	>	checkCompletedWithWrappedCFException(h, ex);
1073	>	checkCompletedWithWrappedCFException(g, ex);
1074	>	assertEquals(r.invocationCount, 0);
1075	>	checkCompletedNormally(f, v1);
1076	>	}
1077	>	}
1078	>
1079	>	public void testThenCombine_exceptionalCompletion3() {
1080	>	for (ExecutionMode m : ExecutionMode.values())
1081	>	for (Integer v1 : new Integer[] { 1, null }) {
1082	>
1083	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1084	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1085	>	final SubtractFunction r = new SubtractFunction();
1086	>	final CFException ex = new CFException();
1087	>
1088	>	g.completeExceptionally(ex);
1089	>	f.complete(v1);
1090	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1091	>
1092	>	checkCompletedWithWrappedCFException(h, ex);
1093	>	checkCompletedWithWrappedCFException(g, ex);
1094	>	assertEquals(r.invocationCount, 0);
1095	>	checkCompletedNormally(f, v1);
1096	>	}
1097	>	}
1098	>
1099	>	public void testThenCombine_exceptionalCompletion4() {
1100	>	for (ExecutionMode m : ExecutionMode.values())
1101	>	for (Integer v1 : new Integer[] { 1, null }) {
1102	>
1103	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1104	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1105	>	final SubtractFunction r = new SubtractFunction();
1106	>	final CFException ex = new CFException();
1107	>
1108	>	f.completeExceptionally(ex);
1109	>	g.complete(v1);
1110	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1111	>
1112	>	checkCompletedWithWrappedCFException(h, ex);
1113	>	checkCompletedWithWrappedCFException(f, ex);
1114	>	assertEquals(r.invocationCount, 0);
1115	>	checkCompletedNormally(g, v1);
1116	>	}
1117		}
1118
1119		/**
1120		* thenCombine result completes exceptionally if action does
1121		*/
1122	<	public void testThenCombine3() {
1123	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1124	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1125	<	FailingBiFunction r = new FailingBiFunction();
1126	<	CompletableFuture<Integer> g = f.thenCombine(f2, r);
1127	<	f.complete(one);
1128	<	checkIncomplete(g);
1129	<	f2.complete(two);
1130	<	checkCompletedWithWrappedCFException(g);
1122	>	public void testThenCombine_actionFailed1() {
1123	>	for (ExecutionMode m : ExecutionMode.values())
1124	>	for (Integer v1 : new Integer[] { 1, null })
1125	>	for (Integer v2 : new Integer[] { 2, null }) {
1126	>
1127	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1128	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1129	>	final FailingBiFunction r = new FailingBiFunction();
1130	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1131	>
1132	>	f.complete(v1);
1133	>	checkIncomplete(h);
1134	>	g.complete(v2);
1135	>
1136	>	checkCompletedWithWrappedCFException(h);
1137	>	checkCompletedNormally(f, v1);
1138	>	checkCompletedNormally(g, v2);
1139	>	}
1140	>	}
1141	>
1142	>	public void testThenCombine_actionFailed2() {
1143	>	for (ExecutionMode m : ExecutionMode.values())
1144	>	for (Integer v1 : new Integer[] { 1, null })
1145	>	for (Integer v2 : new Integer[] { 2, null }) {
1146	>
1147	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1148	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1149	>	final FailingBiFunction r = new FailingBiFunction();
1150	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1151	>
1152	>	g.complete(v2);
1153	>	checkIncomplete(h);
1154	>	f.complete(v1);
1155	>
1156	>	checkCompletedWithWrappedCFException(h);
1157	>	checkCompletedNormally(f, v1);
1158	>	checkCompletedNormally(g, v2);
1159	>	}
1160		}
1161
1162		/**
1163		* thenCombine result completes exceptionally if either source cancelled
1164		*/
1165	<	public void testThenCombine4() {
1166	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1167	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1168	<	CompletableFuture<Integer> g = f.thenCombine(f2, add);
1169	<	assertTrue(f.cancel(true));
1170	<	f2.complete(two);
1171	<	checkCompletedWithWrappedCancellationException(g);
1172	<	f = new CompletableFuture<Integer>();
1173	<	f2 = new CompletableFuture<Integer>();
1174	<	g = f.thenCombine(f2, add);
1175	<	f.complete(one);
1176	<	assertTrue(f2.cancel(true));
1177	<	checkCompletedWithWrappedCancellationException(g);
1165	>	public void testThenCombine_sourceCancelled1() {
1166	>	for (ExecutionMode m : ExecutionMode.values())
1167	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1168	>	for (Integer v1 : new Integer[] { 1, null }) {
1169	>
1170	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1171	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1172	>	final SubtractFunction r = new SubtractFunction();
1173	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1174	>
1175	>	assertTrue(f.cancel(mayInterruptIfRunning));
1176	>	checkIncomplete(h);
1177	>	g.complete(v1);
1178	>
1179	>	checkCompletedWithWrappedCancellationException(h);
1180	>	checkCancelled(f);
1181	>	assertEquals(r.invocationCount, 0);
1182	>	checkCompletedNormally(g, v1);
1183	>	}
1184	>	}
1185	>
1186	>	public void testThenCombine_sourceCancelled2() {
1187	>	for (ExecutionMode m : ExecutionMode.values())
1188	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1189	>	for (Integer v1 : new Integer[] { 1, null }) {
1190	>
1191	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1192	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1193	>	final SubtractFunction r = new SubtractFunction();
1194	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1195	>
1196	>	assertTrue(g.cancel(mayInterruptIfRunning));
1197	>	checkIncomplete(h);
1198	>	f.complete(v1);
1199	>
1200	>	checkCompletedWithWrappedCancellationException(h);
1201	>	checkCancelled(g);
1202	>	assertEquals(r.invocationCount, 0);
1203	>	checkCompletedNormally(f, v1);
1204	>	}
1205	>	}
1206	>
1207	>	public void testThenCombine_sourceCancelled3() {
1208	>	for (ExecutionMode m : ExecutionMode.values())
1209	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1210	>	for (Integer v1 : new Integer[] { 1, null }) {
1211	>
1212	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1213	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1214	>	final SubtractFunction r = new SubtractFunction();
1215	>
1216	>	assertTrue(g.cancel(mayInterruptIfRunning));
1217	>	f.complete(v1);
1218	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1219	>
1220	>	checkCompletedWithWrappedCancellationException(h);
1221	>	checkCancelled(g);
1222	>	assertEquals(r.invocationCount, 0);
1223	>	checkCompletedNormally(f, v1);
1224	>	}
1225	>	}
1226	>
1227	>	public void testThenCombine_sourceCancelled4() {
1228	>	for (ExecutionMode m : ExecutionMode.values())
1229	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
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 SubtractFunction r = new SubtractFunction();
1235	>
1236	>	assertTrue(f.cancel(mayInterruptIfRunning));
1237	>	g.complete(v1);
1238	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1239	>
1240	>	checkCompletedWithWrappedCancellationException(h);
1241	>	checkCancelled(f);
1242	>	assertEquals(r.invocationCount, 0);
1243	>	checkCompletedNormally(g, v1);
1244	>	}
1245		}
1246
1247		/**
1248		* thenAcceptBoth result completes normally after normal
1249		* completion of sources
1250		*/
1251	<	public void testThenAcceptBoth() {
1252	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1253	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1254	<	AddAction r = new AddAction();
1255	<	CompletableFuture<Void> g = f.thenAcceptBoth(f2, r);
1256	<	f.complete(one);
1257	<	checkIncomplete(g);
1258	<	f2.complete(two);
1259	<	checkCompletedNormally(g, null);
1260	<	assertEquals(r.value, 3);
1251	>	public void testThenAcceptBoth_normalCompletion1() {
1252	>	for (ExecutionMode m : ExecutionMode.values())
1253	>	for (Integer v1 : new Integer[] { 1, null })
1254	>	for (Integer v2 : new Integer[] { 2, null }) {
1255	>
1256	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1257	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1258	>	final SubtractAction r = new SubtractAction();
1259	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1260	>
1261	>	f.complete(v1);
1262	>	checkIncomplete(h);
1263	>	assertFalse(r.ran());
1264	>	g.complete(v2);
1265	>
1266	>	checkCompletedNormally(h, null);
1267	>	assertEquals(r.value, subtract(v1, v2));
1268	>	checkCompletedNormally(f, v1);
1269	>	checkCompletedNormally(g, v2);
1270	>	}
1271	>	}
1272
1273	<	r = new AddAction();
1274	<	f = new CompletableFuture<Integer>();
1275	<	f.complete(one);
1276	<	f2 = new CompletableFuture<Integer>();
1277	<	g = f.thenAcceptBoth(f2, r);
1278	<	checkIncomplete(g);
1279	<	f2.complete(two);
1280	<	checkCompletedNormally(g, null);
1281	<	assertEquals(r.value, 3);
1273	>	public void testThenAcceptBoth_normalCompletion2() {
1274	>	for (ExecutionMode m : ExecutionMode.values())
1275	>	for (Integer v1 : new Integer[] { 1, null })
1276	>	for (Integer v2 : new Integer[] { 2, null }) {
1277	>
1278	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1279	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1280	>	final SubtractAction r = new SubtractAction();
1281	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1282	>
1283	>	g.complete(v2);
1284	>	checkIncomplete(h);
1285	>	assertFalse(r.ran());
1286	>	f.complete(v1);
1287	>
1288	>	checkCompletedNormally(h, null);
1289	>	assertEquals(r.value, subtract(v1, v2));
1290	>	checkCompletedNormally(f, v1);
1291	>	checkCompletedNormally(g, v2);
1292	>	}
1293	>	}
1294	>
1295	>	public void testThenAcceptBoth_normalCompletion3() {
1296	>	for (ExecutionMode m : ExecutionMode.values())
1297	>	for (Integer v1 : new Integer[] { 1, null })
1298	>	for (Integer v2 : new Integer[] { 2, null }) {
1299	>
1300	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1301	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1302	>	final SubtractAction r = new SubtractAction();
1303	>
1304	>	g.complete(v2);
1305	>	f.complete(v1);
1306	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1307	>
1308	>	checkCompletedNormally(h, null);
1309	>	assertEquals(r.value, subtract(v1, v2));
1310	>	checkCompletedNormally(f, v1);
1311	>	checkCompletedNormally(g, v2);
1312	>	}
1313	>	}
1314	>
1315	>	public void testThenAcceptBoth_normalCompletion4() {
1316	>	for (ExecutionMode m : ExecutionMode.values())
1317	>	for (Integer v1 : new Integer[] { 1, null })
1318	>	for (Integer v2 : new Integer[] { 2, null }) {
1319	>
1320	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1321	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1322	>	final SubtractAction r = new SubtractAction();
1323	>
1324	>	f.complete(v1);
1325	>	g.complete(v2);
1326	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1327	>
1328	>	checkCompletedNormally(h, null);
1329	>	assertEquals(r.value, subtract(v1, v2));
1330	>	checkCompletedNormally(f, v1);
1331	>	checkCompletedNormally(g, v2);
1332	>	}
1333		}
1334
1335		/**
1336		* thenAcceptBoth result completes exceptionally after exceptional
1337		* completion of either source
1338		*/
1339	<	public void testThenAcceptBoth2() {
1340	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1341	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1342	<	AddAction r = new AddAction();
1343	<	CompletableFuture<Void> g = f.thenAcceptBoth(f2, r);
1344	<	f.completeExceptionally(new CFException());
1345	<	f2.complete(two);
1346	<	checkCompletedWithWrappedCFException(g);
1339	>	public void testThenAcceptBoth_exceptionalCompletion1() {
1340	>	for (ExecutionMode m : ExecutionMode.values())
1341	>	for (Integer v1 : new Integer[] { 1, null }) {
1342	>
1343	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1344	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1345	>	final SubtractAction r = new SubtractAction();
1346	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1347	>	final CFException ex = new CFException();
1348	>
1349	>	f.completeExceptionally(ex);
1350	>	checkIncomplete(h);
1351	>	g.complete(v1);
1352	>
1353	>	checkCompletedWithWrappedCFException(h, ex);
1354	>	checkCompletedWithWrappedCFException(f, ex);
1355	>	assertEquals(r.invocationCount, 0);
1356	>	checkCompletedNormally(g, v1);
1357	>	}
1358	>	}
1359
1360	<	r = new AddAction();
1361	<	f = new CompletableFuture<Integer>();
1362	<	f.complete(one);
1363	<	f2 = new CompletableFuture<Integer>();
1364	<	g = f.thenAcceptBoth(f2, r);
1365	<	f2.completeExceptionally(new CFException());
1366	<	checkCompletedWithWrappedCFException(g);
1360	>	public void testThenAcceptBoth_exceptionalCompletion2() {
1361	>	for (ExecutionMode m : ExecutionMode.values())
1362	>	for (Integer v1 : new Integer[] { 1, null }) {
1363	>
1364	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1365	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1366	>	final SubtractAction r = new SubtractAction();
1367	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1368	>	final CFException ex = new CFException();
1369	>
1370	>	g.completeExceptionally(ex);
1371	>	checkIncomplete(h);
1372	>	f.complete(v1);
1373	>
1374	>	checkCompletedWithWrappedCFException(h, ex);
1375	>	checkCompletedWithWrappedCFException(g, ex);
1376	>	assertEquals(r.invocationCount, 0);
1377	>	checkCompletedNormally(f, v1);
1378	>	}
1379	>	}
1380	>
1381	>	public void testThenAcceptBoth_exceptionalCompletion3() {
1382	>	for (ExecutionMode m : ExecutionMode.values())
1383	>	for (Integer v1 : new Integer[] { 1, null }) {
1384	>
1385	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1386	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1387	>	final SubtractAction r = new SubtractAction();
1388	>	final CFException ex = new CFException();
1389	>
1390	>	g.completeExceptionally(ex);
1391	>	f.complete(v1);
1392	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1393	>
1394	>	checkCompletedWithWrappedCFException(h, ex);
1395	>	checkCompletedWithWrappedCFException(g, ex);
1396	>	assertEquals(r.invocationCount, 0);
1397	>	checkCompletedNormally(f, v1);
1398	>	}
1399	>	}
1400	>
1401	>	public void testThenAcceptBoth_exceptionalCompletion4() {
1402	>	for (ExecutionMode m : ExecutionMode.values())
1403	>	for (Integer v1 : new Integer[] { 1, null }) {
1404	>
1405	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1406	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1407	>	final SubtractAction r = new SubtractAction();
1408	>	final CFException ex = new CFException();
1409	>
1410	>	f.completeExceptionally(ex);
1411	>	g.complete(v1);
1412	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1413	>
1414	>	checkCompletedWithWrappedCFException(h, ex);
1415	>	checkCompletedWithWrappedCFException(f, ex);
1416	>	assertFalse(r.ran());
1417	>	checkCompletedNormally(g, v1);
1418	>	}
1419		}
1420
1421		/**
1422		* thenAcceptBoth result completes exceptionally if action does
1423		*/
1424	<	public void testThenAcceptBoth3() {
1425	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1426	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1427	<	FailingBiConsumer r = new FailingBiConsumer();
1428	<	CompletableFuture<Void> g = f.thenAcceptBoth(f2, r);
1429	<	f.complete(one);
1430	<	checkIncomplete(g);
1431	<	f2.complete(two);
1432	<	checkCompletedWithWrappedCFException(g);
1424	>	public void testThenAcceptBoth_actionFailed1() {
1425	>	for (ExecutionMode m : ExecutionMode.values())
1426	>	for (Integer v1 : new Integer[] { 1, null })
1427	>	for (Integer v2 : new Integer[] { 2, null }) {
1428	>
1429	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1430	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1431	>	final FailingBiConsumer r = new FailingBiConsumer();
1432	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1433	>
1434	>	f.complete(v1);
1435	>	checkIncomplete(h);
1436	>	g.complete(v2);
1437	>
1438	>	checkCompletedWithWrappedCFException(h);
1439	>	checkCompletedNormally(f, v1);
1440	>	checkCompletedNormally(g, v2);
1441	>	}
1442	>	}
1443	>
1444	>	public void testThenAcceptBoth_actionFailed2() {
1445	>	for (ExecutionMode m : ExecutionMode.values())
1446	>	for (Integer v1 : new Integer[] { 1, null })
1447	>	for (Integer v2 : new Integer[] { 2, null }) {
1448	>
1449	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1450	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1451	>	final FailingBiConsumer r = new FailingBiConsumer();
1452	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1453	>
1454	>	g.complete(v2);
1455	>	checkIncomplete(h);
1456	>	f.complete(v1);
1457	>
1458	>	checkCompletedWithWrappedCFException(h);
1459	>	checkCompletedNormally(f, v1);
1460	>	checkCompletedNormally(g, v2);
1461	>	}
1462		}
1463
1464		/**
1465		* thenAcceptBoth result completes exceptionally if either source cancelled
1466		*/
1467	<	public void testThenAcceptBoth4() {
1468	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1469	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1470	<	AddAction r = new AddAction();
1471	<	CompletableFuture<Void> g = f.thenAcceptBoth(f2, r);
1472	<	assertTrue(f.cancel(true));
1473	<	f2.complete(two);
1474	<	checkCompletedWithWrappedCancellationException(g);
1475	<	f = new CompletableFuture<Integer>();
1476	<	f2 = new CompletableFuture<Integer>();
1477	<	r = new AddAction();
1478	<	g = f.thenAcceptBoth(f2, r);
1479	<	f.complete(one);
1480	<	assertTrue(f2.cancel(true));
1481	<	checkCompletedWithWrappedCancellationException(g);
1467	>	public void testThenAcceptBoth_sourceCancelled1() {
1468	>	for (ExecutionMode m : ExecutionMode.values())
1469	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1470	>	for (Integer v1 : new Integer[] { 1, null }) {
1471	>
1472	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1473	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1474	>	final SubtractAction r = new SubtractAction();
1475	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1476	>
1477	>	assertTrue(f.cancel(mayInterruptIfRunning));
1478	>	checkIncomplete(h);
1479	>	g.complete(v1);
1480	>
1481	>	checkCompletedWithWrappedCancellationException(h);
1482	>	checkCancelled(f);
1483	>	assertEquals(r.invocationCount, 0);
1484	>	checkCompletedNormally(g, v1);
1485	>	}
1486	>	}
1487	>
1488	>	public void testThenAcceptBoth_sourceCancelled2() {
1489	>	for (ExecutionMode m : ExecutionMode.values())
1490	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1491	>	for (Integer v1 : new Integer[] { 1, null }) {
1492	>
1493	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1494	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1495	>	final SubtractAction r = new SubtractAction();
1496	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1497	>
1498	>	assertTrue(g.cancel(mayInterruptIfRunning));
1499	>	checkIncomplete(h);
1500	>	f.complete(v1);
1501	>
1502	>	checkCompletedWithWrappedCancellationException(h);
1503	>	checkCancelled(g);
1504	>	assertEquals(r.invocationCount, 0);
1505	>	checkCompletedNormally(f, v1);
1506	>	}
1507	>	}
1508	>
1509	>	public void testThenAcceptBoth_sourceCancelled3() {
1510	>	for (ExecutionMode m : ExecutionMode.values())
1511	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1512	>	for (Integer v1 : new Integer[] { 1, null }) {
1513	>
1514	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1515	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1516	>	final SubtractAction r = new SubtractAction();
1517	>
1518	>	assertTrue(g.cancel(mayInterruptIfRunning));
1519	>	f.complete(v1);
1520	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1521	>
1522	>	checkCompletedWithWrappedCancellationException(h);
1523	>	checkCancelled(g);
1524	>	assertEquals(r.invocationCount, 0);
1525	>	checkCompletedNormally(f, v1);
1526	>	}
1527	>	}
1528	>
1529	>	public void testThenAcceptBoth_sourceCancelled4() {
1530	>	for (ExecutionMode m : ExecutionMode.values())
1531	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1532	>	for (Integer v1 : new Integer[] { 1, null }) {
1533	>
1534	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1535	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1536	>	final SubtractAction r = new SubtractAction();
1537	>
1538	>	assertTrue(f.cancel(mayInterruptIfRunning));
1539	>	g.complete(v1);
1540	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1541	>
1542	>	checkCompletedWithWrappedCancellationException(h);
1543	>	checkCancelled(f);
1544	>	assertEquals(r.invocationCount, 0);
1545	>	checkCompletedNormally(g, v1);
1546	>	}
1547		}
1548
1549		/**
1550		* runAfterBoth result completes normally after normal
1551		* completion of sources
1552		*/
1553	<	public void testRunAfterBoth() {
1554	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1555	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1556	<	Noop r = new Noop();
1557	<	CompletableFuture<Void> g = f.runAfterBoth(f2, r);
1558	<	f.complete(one);
1559	<	checkIncomplete(g);
1560	<	f2.complete(two);
1561	<	checkCompletedNormally(g, null);
1562	<	assertTrue(r.ran);
1553	>	public void testRunAfterBoth_normalCompletion1() {
1554	>	for (ExecutionMode m : ExecutionMode.values())
1555	>	for (Integer v1 : new Integer[] { 1, null })
1556	>	for (Integer v2 : new Integer[] { 2, null }) {
1557	>
1558	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1559	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1560	>	final Noop r = new Noop();
1561	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1562	>
1563	>	f.complete(v1);
1564	>	checkIncomplete(h);
1565	>	assertFalse(r.ran);
1566	>	g.complete(v2);
1567	>
1568	>	checkCompletedNormally(h, null);
1569	>	assertEquals(r.invocationCount, 1);
1570	>	checkCompletedNormally(f, v1);
1571	>	checkCompletedNormally(g, v2);
1572	>	}
1573	>	}
1574
1575	<	r = new Noop();
1576	<	f = new CompletableFuture<Integer>();
1577	<	f.complete(one);
1578	<	f2 = new CompletableFuture<Integer>();
1579	<	g = f.runAfterBoth(f2, r);
1580	<	checkIncomplete(g);
1581	<	f2.complete(two);
1582	<	checkCompletedNormally(g, null);
1575	>	public void testRunAfterBoth_normalCompletion2() {
1576	>	for (ExecutionMode m : ExecutionMode.values())
1577	>	for (Integer v1 : new Integer[] { 1, null })
1578	>	for (Integer v2 : new Integer[] { 2, null }) {
1579	>
1580	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1581	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1582	>	final Noop r = new Noop();
1583	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1584	>
1585	>	g.complete(v2);
1586	>	checkIncomplete(h);
1587	>	assertFalse(r.ran);
1588	>	f.complete(v1);
1589	>
1590	>	checkCompletedNormally(h, null);
1591	>	assertEquals(r.invocationCount, 1);
1592	>	checkCompletedNormally(f, v1);
1593	>	checkCompletedNormally(g, v2);
1594	>	}
1595	>	}
1596	>
1597	>	public void testRunAfterBoth_normalCompletion3() {
1598	>	for (ExecutionMode m : ExecutionMode.values())
1599	>	for (Integer v1 : new Integer[] { 1, null })
1600	>	for (Integer v2 : new Integer[] { 2, null }) {
1601	>
1602	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1603	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1604	>	final Noop r = new Noop();
1605	>
1606	>	g.complete(v2);
1607	>	f.complete(v1);
1608	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1609	>
1610	>	checkCompletedNormally(h, null);
1611		assertTrue(r.ran);
1612	+	checkCompletedNormally(f, v1);
1613	+	checkCompletedNormally(g, v2);
1614	+	}
1615	+	}
1616	+
1617	+	public void testRunAfterBoth_normalCompletion4() {
1618	+	for (ExecutionMode m : ExecutionMode.values())
1619	+	for (Integer v1 : new Integer[] { 1, null })
1620	+	for (Integer v2 : new Integer[] { 2, null }) {
1621	+
1622	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
1623	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
1624	+	final Noop r = new Noop();
1625	+
1626	+	f.complete(v1);
1627	+	g.complete(v2);
1628	+	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1629	+
1630	+	checkCompletedNormally(h, null);
1631	+	assertEquals(r.invocationCount, 1);
1632	+	checkCompletedNormally(f, v1);
1633	+	checkCompletedNormally(g, v2);
1634	+	}
1635		}
1636
1637		/**
1638		* runAfterBoth result completes exceptionally after exceptional
1639		* completion of either source
1640		*/
1641	<	public void testRunAfterBoth2() {
1642	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1643	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1644	<	Noop r = new Noop();
1645	<	CompletableFuture<Void> g = f.runAfterBoth(f2, r);
1646	<	f.completeExceptionally(new CFException());
1647	<	f2.complete(two);
1648	<	checkCompletedWithWrappedCFException(g);
1641	>	public void testRunAfterBoth_exceptionalCompletion1() {
1642	>	for (ExecutionMode m : ExecutionMode.values())
1643	>	for (Integer v1 : new Integer[] { 1, null }) {
1644	>
1645	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1646	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1647	>	final Noop r = new Noop();
1648	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1649	>	final CFException ex = new CFException();
1650	>
1651	>	f.completeExceptionally(ex);
1652	>	checkIncomplete(h);
1653	>	g.complete(v1);
1654	>
1655	>	checkCompletedWithWrappedCFException(h, ex);
1656	>	checkCompletedWithWrappedCFException(f, ex);
1657	>	assertEquals(r.invocationCount, 0);
1658	>	checkCompletedNormally(g, v1);
1659	>	}
1660	>	}
1661
1662	<	r = new Noop();
1663	<	f = new CompletableFuture<Integer>();
1664	<	f.complete(one);
1665	<	f2 = new CompletableFuture<Integer>();
1666	<	g = f.runAfterBoth(f2, r);
1667	<	f2.completeExceptionally(new CFException());
1668	<	checkCompletedWithWrappedCFException(g);
1662	>	public void testRunAfterBoth_exceptionalCompletion2() {
1663	>	for (ExecutionMode m : ExecutionMode.values())
1664	>	for (Integer v1 : new Integer[] { 1, null }) {
1665	>
1666	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1667	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1668	>	final Noop r = new Noop();
1669	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1670	>	final CFException ex = new CFException();
1671	>
1672	>	g.completeExceptionally(ex);
1673	>	checkIncomplete(h);
1674	>	f.complete(v1);
1675	>
1676	>	checkCompletedWithWrappedCFException(h, ex);
1677	>	checkCompletedWithWrappedCFException(g, ex);
1678	>	assertEquals(r.invocationCount, 0);
1679	>	checkCompletedNormally(f, v1);
1680	>	}
1681	>	}
1682	>
1683	>	public void testRunAfterBoth_exceptionalCompletion3() {
1684	>	for (ExecutionMode m : ExecutionMode.values())
1685	>	for (Integer v1 : new Integer[] { 1, null }) {
1686	>
1687	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1688	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1689	>	final Noop r = new Noop();
1690	>	final CFException ex = new CFException();
1691	>
1692	>	g.completeExceptionally(ex);
1693	>	f.complete(v1);
1694	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1695	>
1696	>	checkCompletedWithWrappedCFException(h, ex);
1697	>	checkCompletedWithWrappedCFException(g, ex);
1698	>	assertEquals(r.invocationCount, 0);
1699	>	checkCompletedNormally(f, v1);
1700	>	}
1701	>	}
1702	>
1703	>	public void testRunAfterBoth_exceptionalCompletion4() {
1704	>	for (ExecutionMode m : ExecutionMode.values())
1705	>	for (Integer v1 : new Integer[] { 1, null }) {
1706	>
1707	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1708	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1709	>	final Noop r = new Noop();
1710	>	final CFException ex = new CFException();
1711	>
1712	>	f.completeExceptionally(ex);
1713	>	g.complete(v1);
1714	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1715	>
1716	>	checkCompletedWithWrappedCFException(h, ex);
1717	>	checkCompletedWithWrappedCFException(f, ex);
1718	>	assertEquals(r.invocationCount, 0);
1719	>	checkCompletedNormally(g, v1);
1720	>	}
1721		}
1722
1723		/**
1724		* runAfterBoth result completes exceptionally if action does
1725		*/
1726	<	public void testRunAfterBoth3() {
1727	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1728	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1729	<	FailingNoop r = new FailingNoop();
1730	<	CompletableFuture<Void> g = f.runAfterBoth(f2, r);
1731	<	f.complete(one);
1732	<	checkIncomplete(g);
1733	<	f2.complete(two);
1734	<	checkCompletedWithWrappedCFException(g);
1726	>	public void testRunAfterBoth_actionFailed1() {
1727	>	for (ExecutionMode m : ExecutionMode.values())
1728	>	for (Integer v1 : new Integer[] { 1, null })
1729	>	for (Integer v2 : new Integer[] { 2, null }) {
1730	>
1731	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1732	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1733	>	final FailingNoop r = new FailingNoop();
1734	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1735	>
1736	>	f.complete(v1);
1737	>	checkIncomplete(h);
1738	>	g.complete(v2);
1739	>
1740	>	checkCompletedWithWrappedCFException(h);
1741	>	checkCompletedNormally(f, v1);
1742	>	checkCompletedNormally(g, v2);
1743	>	}
1744	>	}
1745	>
1746	>	public void testRunAfterBoth_actionFailed2() {
1747	>	for (ExecutionMode m : ExecutionMode.values())
1748	>	for (Integer v1 : new Integer[] { 1, null })
1749	>	for (Integer v2 : new Integer[] { 2, null }) {
1750	>
1751	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1752	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1753	>	final FailingNoop r = new FailingNoop();
1754	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1755	>
1756	>	g.complete(v2);
1757	>	checkIncomplete(h);
1758	>	f.complete(v1);
1759	>
1760	>	checkCompletedWithWrappedCFException(h);
1761	>	checkCompletedNormally(f, v1);
1762	>	checkCompletedNormally(g, v2);
1763	>	}
1764		}
1765
1766		/**
1767		* runAfterBoth result completes exceptionally if either source cancelled
1768		*/
1769	<	public void testRunAfterBoth4() {
1770	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1771	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1772	<	Noop r = new Noop();
1773	<	CompletableFuture<Void> g = f.runAfterBoth(f2, r);
1774	<	assertTrue(f.cancel(true));
1775	<	f2.complete(two);
1776	<	checkCompletedWithWrappedCancellationException(g);
1777	<	f = new CompletableFuture<Integer>();
1778	<	f2 = new CompletableFuture<Integer>();
1779	<	r = new Noop();
1780	<	g = f.runAfterBoth(f2, r);
1781	<	f.complete(one);
1782	<	assertTrue(f2.cancel(true));
1783	<	checkCompletedWithWrappedCancellationException(g);
1769	>	public void testRunAfterBoth_sourceCancelled1() {
1770	>	for (ExecutionMode m : ExecutionMode.values())
1771	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1772	>	for (Integer v1 : new Integer[] { 1, null }) {
1773	>
1774	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1775	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1776	>	final Noop r = new Noop();
1777	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1778	>
1779	>	assertTrue(f.cancel(mayInterruptIfRunning));
1780	>	checkIncomplete(h);
1781	>	g.complete(v1);
1782	>
1783	>	checkCompletedWithWrappedCancellationException(h);
1784	>	checkCancelled(f);
1785	>	assertEquals(r.invocationCount, 0);
1786	>	checkCompletedNormally(g, v1);
1787	>	}
1788	>	}
1789	>
1790	>	public void testRunAfterBoth_sourceCancelled2() {
1791	>	for (ExecutionMode m : ExecutionMode.values())
1792	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1793	>	for (Integer v1 : new Integer[] { 1, null }) {
1794	>
1795	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1796	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1797	>	final Noop r = new Noop();
1798	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1799	>
1800	>	assertTrue(g.cancel(mayInterruptIfRunning));
1801	>	checkIncomplete(h);
1802	>	f.complete(v1);
1803	>
1804	>	checkCompletedWithWrappedCancellationException(h);
1805	>	checkCancelled(g);
1806	>	assertEquals(r.invocationCount, 0);
1807	>	checkCompletedNormally(f, v1);
1808	>	}
1809	>	}
1810	>
1811	>	public void testRunAfterBoth_sourceCancelled3() {
1812	>	for (ExecutionMode m : ExecutionMode.values())
1813	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1814	>	for (Integer v1 : new Integer[] { 1, null }) {
1815	>
1816	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1817	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1818	>	final Noop r = new Noop();
1819	>
1820	>	assertTrue(g.cancel(mayInterruptIfRunning));
1821	>	f.complete(v1);
1822	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1823	>
1824	>	checkCompletedWithWrappedCancellationException(h);
1825	>	checkCancelled(g);
1826	>	assertEquals(r.invocationCount, 0);
1827	>	checkCompletedNormally(f, v1);
1828	>	}
1829	>	}
1830	>
1831	>	public void testRunAfterBoth_sourceCancelled4() {
1832	>	for (ExecutionMode m : ExecutionMode.values())
1833	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1834	>	for (Integer v1 : new Integer[] { 1, null }) {
1835	>
1836	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1837	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1838	>	final Noop r = new Noop();
1839	>
1840	>	assertTrue(f.cancel(mayInterruptIfRunning));
1841	>	g.complete(v1);
1842	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1843	>
1844	>	checkCompletedWithWrappedCancellationException(h);
1845	>	checkCancelled(f);
1846	>	assertEquals(r.invocationCount, 0);
1847	>	checkCompletedNormally(g, v1);
1848	>	}
1849		}
1850
1851		/**
1852		* applyToEither result completes normally after normal completion
1853		* of either source
1854		*/
1855	<	public void testApplyToEither() {
1856	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1857	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1858	<	CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1859	<	f.complete(one);
1860	<	checkCompletedNormally(g, two);
1861	<	f2.complete(one);
1862	<	checkCompletedNormally(g, two);
1855	>	public void testApplyToEither_normalCompletion1() {
1856	>	for (ExecutionMode m : ExecutionMode.values())
1857	>	for (Integer v1 : new Integer[] { 1, null })
1858	>	for (Integer v2 : new Integer[] { 2, null }) {
1859	>
1860	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1861	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1862	>	final IncFunction r = new IncFunction();
1863	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1864	>
1865	>	f.complete(v1);
1866	>	checkCompletedNormally(h, inc(v1));
1867	>	g.complete(v2);
1868	>
1869	>	checkCompletedNormally(f, v1);
1870	>	checkCompletedNormally(g, v2);
1871	>	checkCompletedNormally(h, inc(v1));
1872	>	}
1873	>	}
1874
1875	<	f = new CompletableFuture<Integer>();
1876	<	f.complete(one);
1877	<	f2 = new CompletableFuture<Integer>();
1878	<	g = f.applyToEither(f2, inc);
1879	<	checkCompletedNormally(g, two);
1875	>	public void testApplyToEither_normalCompletion2() {
1876	>	for (ExecutionMode m : ExecutionMode.values())
1877	>	for (Integer v1 : new Integer[] { 1, null })
1878	>	for (Integer v2 : new Integer[] { 2, null }) {
1879	>
1880	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1881	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1882	>	final IncFunction r = new IncFunction();
1883	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1884	>
1885	>	g.complete(v2);
1886	>	checkCompletedNormally(h, inc(v2));
1887	>	f.complete(v1);
1888	>
1889	>	checkCompletedNormally(f, v1);
1890	>	checkCompletedNormally(g, v2);
1891	>	checkCompletedNormally(h, inc(v2));
1892	>	}
1893	>	}
1894	>	public void testApplyToEither_normalCompletion3() {
1895	>	for (ExecutionMode m : ExecutionMode.values())
1896	>	for (Integer v1 : new Integer[] { 1, null })
1897	>	for (Integer v2 : new Integer[] { 2, null }) {
1898	>
1899	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1900	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1901	>	final IncFunction r = new IncFunction();
1902	>
1903	>	f.complete(v1);
1904	>	g.complete(v2);
1905	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1906	>
1907	>	checkCompletedNormally(f, v1);
1908	>	checkCompletedNormally(g, v2);
1909	>
1910	>	// unspecified behavior
1911	>	assertTrue(Objects.equals(h.join(), inc(v1)) ||
1912	>	Objects.equals(h.join(), inc(v2)));
1913	>	assertEquals(r.invocationCount, 1);
1914	>	}
1915		}
1916
1917		/**
1918		* applyToEither result completes exceptionally after exceptional
1919		* completion of either source
1920		*/
1921	<	public void testApplyToEither2() {
1922	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1923	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1924	<	CompletableFuture<Integer> g = f.applyToEither(f2, inc);
1925	<	f.completeExceptionally(new CFException());
1926	<	f2.complete(one);
1927	<	checkCompletedWithWrappedCFException(g);
1921	>	public void testApplyToEither_exceptionalCompletion1() {
1922	>	for (ExecutionMode m : ExecutionMode.values())
1923	>	for (Integer v1 : new Integer[] { 1, null }) {
1924	>
1925	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1926	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1927	>	final IncFunction r = new IncFunction();
1928	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1929	>	final CFException ex = new CFException();
1930	>
1931	>	f.completeExceptionally(ex);
1932	>	checkCompletedWithWrappedCFException(h, ex);
1933	>	g.complete(v1);
1934	>
1935	>	assertEquals(r.invocationCount, 0);
1936	>	checkCompletedNormally(g, v1);
1937	>	checkCompletedWithWrappedCFException(f, ex);
1938	>	checkCompletedWithWrappedCFException(h, ex);
1939	>	}
1940	>	}
1941
1942	<	f = new CompletableFuture<Integer>();
1943	<	f2 = new CompletableFuture<Integer>();
1944	<	f2.completeExceptionally(new CFException());
1945	<	g = f.applyToEither(f2, inc);
1946	<	checkCompletedWithWrappedCFException(g);
1942	>	public void testApplyToEither_exceptionalCompletion2() {
1943	>	for (ExecutionMode m : ExecutionMode.values())
1944	>	for (Integer v1 : new Integer[] { 1, null }) {
1945	>
1946	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1947	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1948	>	final IncFunction r = new IncFunction();
1949	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1950	>	final CFException ex = new CFException();
1951	>
1952	>	g.completeExceptionally(ex);
1953	>	checkCompletedWithWrappedCFException(h, ex);
1954	>	f.complete(v1);
1955	>
1956	>	assertEquals(r.invocationCount, 0);
1957	>	checkCompletedNormally(f, v1);
1958	>	checkCompletedWithWrappedCFException(g, ex);
1959	>	checkCompletedWithWrappedCFException(h, ex);
1960	>	}
1961	>	}
1962	>
1963	>	public void testApplyToEither_exceptionalCompletion3() {
1964	>	for (ExecutionMode m : ExecutionMode.values())
1965	>	for (Integer v1 : new Integer[] { 1, null }) {
1966	>
1967	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1968	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1969	>	final IncFunction r = new IncFunction();
1970	>	final CFException ex = new CFException();
1971	>
1972	>	g.completeExceptionally(ex);
1973	>	f.complete(v1);
1974	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1975	>
1976	>	// unspecified behavior
1977	>	Integer v;
1978	>	try {
1979	>	assertEquals(h.join(), inc(v1));
1980	>	assertEquals(r.invocationCount, 1);
1981	>	} catch (CompletionException ok) {
1982	>	checkCompletedWithWrappedCFException(h, ex);
1983	>	assertEquals(r.invocationCount, 0);
1984	>	}
1985	>
1986	>	checkCompletedWithWrappedCFException(g, ex);
1987	>	checkCompletedNormally(f, v1);
1988	>	}
1989	>	}
1990	>
1991	>	public void testApplyToEither_exceptionalCompletion4() {
1992	>	for (ExecutionMode m : ExecutionMode.values())
1993	>	for (Integer v1 : new Integer[] { 1, null }) {
1994	>
1995	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1996	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1997	>	final IncFunction r = new IncFunction();
1998	>	final CFException ex = new CFException();
1999	>
2000	>	f.completeExceptionally(ex);
2001	>	g.complete(v1);
2002	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2003	>
2004	>	// unspecified behavior
2005	>	Integer v;
2006	>	try {
2007	>	assertEquals(h.join(), inc(v1));
2008	>	assertEquals(r.invocationCount, 1);
2009	>	} catch (CompletionException ok) {
2010	>	checkCompletedWithWrappedCFException(h, ex);
2011	>	assertEquals(r.invocationCount, 0);
2012	>	}
2013	>
2014	>	checkCompletedWithWrappedCFException(f, ex);
2015	>	checkCompletedNormally(g, v1);
2016	>	}
2017		}
2018
2019		/**
2020		* applyToEither result completes exceptionally if action does
2021		*/
2022	<	public void testApplyToEither3() {
2023	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2024	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2025	<	FailingFunction r = new FailingFunction();
2026	<	CompletableFuture<Integer> g = f.applyToEither(f2, r);
2027	<	f2.complete(two);
2028	<	checkCompletedWithWrappedCFException(g);
2022	>	public void testApplyToEither_actionFailed1() {
2023	>	for (ExecutionMode m : ExecutionMode.values())
2024	>	for (Integer v1 : new Integer[] { 1, null })
2025	>	for (Integer v2 : new Integer[] { 2, null }) {
2026	>
2027	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2028	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2029	>	final FailingFunction r = new FailingFunction();
2030	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2031	>
2032	>	f.complete(v1);
2033	>	checkCompletedWithWrappedCFException(h);
2034	>	g.complete(v2);
2035	>	checkCompletedNormally(f, v1);
2036	>	checkCompletedNormally(g, v2);
2037	>	}
2038	>	}
2039	>
2040	>	public void testApplyToEither_actionFailed2() {
2041	>	for (ExecutionMode m : ExecutionMode.values())
2042	>	for (Integer v1 : new Integer[] { 1, null })
2043	>	for (Integer v2 : new Integer[] { 2, null }) {
2044	>
2045	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2046	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2047	>	final FailingFunction r = new FailingFunction();
2048	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2049	>
2050	>	g.complete(v2);
2051	>	checkCompletedWithWrappedCFException(h);
2052	>	f.complete(v1);
2053	>	checkCompletedNormally(f, v1);
2054	>	checkCompletedNormally(g, v2);
2055	>	}
2056		}
2057
2058		/**
2059		* applyToEither result completes exceptionally if either source cancelled
2060		*/
2061	<	public void testApplyToEither4() {
2062	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2063	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2064	<	CompletableFuture<Integer> g = f.applyToEither(f2, inc);
2065	<	assertTrue(f.cancel(true));
2066	<	checkCompletedWithWrappedCancellationException(g);
2067	<	f = new CompletableFuture<Integer>();
2068	<	f2 = new CompletableFuture<Integer>();
2069	<	assertTrue(f2.cancel(true));
2070	<	checkCompletedWithWrappedCancellationException(g);
2061	>	public void testApplyToEither_sourceCancelled1() {
2062	>	for (ExecutionMode m : ExecutionMode.values())
2063	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2064	>	for (Integer v1 : new Integer[] { 1, null }) {
2065	>
2066	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2067	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2068	>	final IncFunction r = new IncFunction();
2069	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2070	>
2071	>	assertTrue(f.cancel(mayInterruptIfRunning));
2072	>	checkCompletedWithWrappedCancellationException(h);
2073	>	g.complete(v1);
2074	>
2075	>	checkCancelled(f);
2076	>	assertEquals(r.invocationCount, 0);
2077	>	checkCompletedNormally(g, v1);
2078	>	checkCompletedWithWrappedCancellationException(h);
2079	>	}
2080	>	}
2081	>
2082	>	public void testApplyToEither_sourceCancelled2() {
2083	>	for (ExecutionMode m : ExecutionMode.values())
2084	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2085	>	for (Integer v1 : new Integer[] { 1, null }) {
2086	>
2087	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2088	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2089	>	final IncFunction r = new IncFunction();
2090	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2091	>
2092	>	assertTrue(g.cancel(mayInterruptIfRunning));
2093	>	checkCompletedWithWrappedCancellationException(h);
2094	>	f.complete(v1);
2095	>
2096	>	checkCancelled(g);
2097	>	assertEquals(r.invocationCount, 0);
2098	>	checkCompletedNormally(f, v1);
2099	>	checkCompletedWithWrappedCancellationException(h);
2100	>	}
2101	>	}
2102	>
2103	>	public void testApplyToEither_sourceCancelled3() {
2104	>	for (ExecutionMode m : ExecutionMode.values())
2105	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2106	>	for (Integer v1 : new Integer[] { 1, null }) {
2107	>
2108	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2109	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2110	>	final IncFunction r = new IncFunction();
2111	>
2112	>	assertTrue(g.cancel(mayInterruptIfRunning));
2113	>	f.complete(v1);
2114	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2115	>
2116	>	// unspecified behavior
2117	>	Integer v;
2118	>	try {
2119	>	assertEquals(h.join(), inc(v1));
2120	>	assertEquals(r.invocationCount, 1);
2121	>	} catch (CompletionException ok) {
2122	>	checkCompletedWithWrappedCancellationException(h);
2123	>	assertEquals(r.invocationCount, 0);
2124	>	}
2125	>
2126	>	checkCancelled(g);
2127	>	checkCompletedNormally(f, v1);
2128	>	}
2129	>	}
2130	>
2131	>	public void testApplyToEither_sourceCancelled4() {
2132	>	for (ExecutionMode m : ExecutionMode.values())
2133	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2134	>	for (Integer v1 : new Integer[] { 1, null }) {
2135	>
2136	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2137	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2138	>	final IncFunction r = new IncFunction();
2139	>
2140	>	assertTrue(f.cancel(mayInterruptIfRunning));
2141	>	g.complete(v1);
2142	>	final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2143	>
2144	>	// unspecified behavior
2145	>	Integer v;
2146	>	try {
2147	>	assertEquals(h.join(), inc(v1));
2148	>	assertEquals(r.invocationCount, 1);
2149	>	} catch (CompletionException ok) {
2150	>	checkCompletedWithWrappedCancellationException(h);
2151	>	assertEquals(r.invocationCount, 0);
2152	>	}
2153	>
2154	>	checkCancelled(f);
2155	>	checkCompletedNormally(g, v1);
2156	>	}
2157		}
2158
2159		/**
2160		* acceptEither result completes normally after normal completion
2161		* of either source
2162		*/
2163	<	public void testAcceptEither() {
2164	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2165	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2166	<	IncAction r = new IncAction();
2167	<	CompletableFuture<Void> g = f.acceptEither(f2, r);
2168	<	f.complete(one);
2169	<	checkCompletedNormally(g, null);
2170	<	f2.complete(one);
2171	<	checkCompletedNormally(g, null);
2172	<	assertEquals(r.value, 2);
2163	>	public void testAcceptEither_normalCompletion1() {
2164	>	for (ExecutionMode m : ExecutionMode.values())
2165	>	for (Integer v1 : new Integer[] { 1, null })
2166	>	for (Integer v2 : new Integer[] { 2, null }) {
2167	>
2168	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2169	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2170	>	final IncAction r = new IncAction();
2171	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2172	>
2173	>	f.complete(v1);
2174	>	checkCompletedNormally(h, null);
2175	>	assertEquals(r.value, inc(v1));
2176	>	g.complete(v2);
2177	>
2178	>	checkCompletedNormally(f, v1);
2179	>	checkCompletedNormally(g, v2);
2180	>	checkCompletedNormally(h, null);
2181	>	}
2182	>	}
2183
2184	<	r = new IncAction();
2185	<	f = new CompletableFuture<Integer>();
2186	<	f.complete(one);
2187	<	f2 = new CompletableFuture<Integer>();
2188	<	g = f.acceptEither(f2, r);
2189	<	checkCompletedNormally(g, null);
2190	<	assertEquals(r.value, 2);
2184	>	public void testAcceptEither_normalCompletion2() {
2185	>	for (ExecutionMode m : ExecutionMode.values())
2186	>	for (Integer v1 : new Integer[] { 1, null })
2187	>	for (Integer v2 : new Integer[] { 2, null }) {
2188	>
2189	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2190	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2191	>	final IncAction r = new IncAction();
2192	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2193	>
2194	>	g.complete(v2);
2195	>	checkCompletedNormally(h, null);
2196	>	assertEquals(r.value, inc(v2));
2197	>	f.complete(v1);
2198	>
2199	>	checkCompletedNormally(f, v1);
2200	>	checkCompletedNormally(g, v2);
2201	>	checkCompletedNormally(h, null);
2202	>	}
2203	>	}
2204	>	public void testAcceptEither_normalCompletion3() {
2205	>	for (ExecutionMode m : ExecutionMode.values())
2206	>	for (Integer v1 : new Integer[] { 1, null })
2207	>	for (Integer v2 : new Integer[] { 2, null }) {
2208	>
2209	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2210	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2211	>	final IncAction r = new IncAction();
2212	>
2213	>	f.complete(v1);
2214	>	g.complete(v2);
2215	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2216	>
2217	>	checkCompletedNormally(h, null);
2218	>	checkCompletedNormally(f, v1);
2219	>	checkCompletedNormally(g, v2);
2220	>
2221	>	// unspecified behavior
2222	>	assertTrue(Objects.equals(r.value, inc(v1)) ||
2223	>	Objects.equals(r.value, inc(v2)));
2224	>	}
2225		}
2226
2227		/**
2228		* acceptEither result completes exceptionally after exceptional
2229		* completion of either source
2230		*/
2231	<	public void testAcceptEither2() {
2232	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2233	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2234	<	IncAction r = new IncAction();
2235	<	CompletableFuture<Void> g = f.acceptEither(f2, r);
2236	<	f.completeExceptionally(new CFException());
2237	<	f2.complete(one);
2238	<	checkCompletedWithWrappedCFException(g);
2231	>	public void testAcceptEither_exceptionalCompletion1() {
2232	>	for (ExecutionMode m : ExecutionMode.values())
2233	>	for (Integer v1 : new Integer[] { 1, null }) {
2234	>
2235	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2236	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2237	>	final IncAction r = new IncAction();
2238	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2239	>	final CFException ex = new CFException();
2240	>
2241	>	f.completeExceptionally(ex);
2242	>	checkCompletedWithWrappedCFException(h, ex);
2243	>	g.complete(v1);
2244	>
2245	>	assertEquals(r.invocationCount, 0);
2246	>	checkCompletedNormally(g, v1);
2247	>	checkCompletedWithWrappedCFException(f, ex);
2248	>	checkCompletedWithWrappedCFException(h, ex);
2249	>	}
2250	>	}
2251
2252	<	r = new IncAction();
2253	<	f = new CompletableFuture<Integer>();
2254	<	f2 = new CompletableFuture<Integer>();
2255	<	f2.completeExceptionally(new CFException());
2256	<	g = f.acceptEither(f2, r);
2257	<	checkCompletedWithWrappedCFException(g);
2252	>	public void testAcceptEither_exceptionalCompletion2() {
2253	>	for (ExecutionMode m : ExecutionMode.values())
2254	>	for (Integer v1 : new Integer[] { 1, null }) {
2255	>
2256	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2257	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2258	>	final IncAction r = new IncAction();
2259	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2260	>	final CFException ex = new CFException();
2261	>
2262	>	g.completeExceptionally(ex);
2263	>	checkCompletedWithWrappedCFException(h, ex);
2264	>	f.complete(v1);
2265	>
2266	>	assertEquals(r.invocationCount, 0);
2267	>	checkCompletedNormally(f, v1);
2268	>	checkCompletedWithWrappedCFException(g, ex);
2269	>	checkCompletedWithWrappedCFException(h, ex);
2270	>	}
2271	>	}
2272	>
2273	>	public void testAcceptEither_exceptionalCompletion3() {
2274	>	for (ExecutionMode m : ExecutionMode.values())
2275	>	for (Integer v1 : new Integer[] { 1, null }) {
2276	>
2277	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2278	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2279	>	final IncAction r = new IncAction();
2280	>	final CFException ex = new CFException();
2281	>
2282	>	g.completeExceptionally(ex);
2283	>	f.complete(v1);
2284	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2285	>
2286	>	// unspecified behavior
2287	>	Integer v;
2288	>	try {
2289	>	assertEquals(h.join(), null);
2290	>	assertEquals(r.invocationCount, 1);
2291	>	assertEquals(inc(v1), r.value);
2292	>	} catch (CompletionException ok) {
2293	>	checkCompletedWithWrappedCFException(h, ex);
2294	>	assertEquals(r.invocationCount, 0);
2295	>	}
2296	>
2297	>	checkCompletedWithWrappedCFException(g, ex);
2298	>	checkCompletedNormally(f, v1);
2299	>	}
2300	>	}
2301	>
2302	>	public void testAcceptEither_exceptionalCompletion4() {
2303	>	for (ExecutionMode m : ExecutionMode.values())
2304	>	for (Integer v1 : new Integer[] { 1, null }) {
2305	>
2306	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2307	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2308	>	final IncAction r = new IncAction();
2309	>	final CFException ex = new CFException();
2310	>
2311	>	f.completeExceptionally(ex);
2312	>	g.complete(v1);
2313	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2314	>
2315	>	// unspecified behavior
2316	>	Integer v;
2317	>	try {
2318	>	assertEquals(h.join(), null);
2319	>	assertEquals(r.invocationCount, 1);
2320	>	assertEquals(inc(v1), r.value);
2321	>	} catch (CompletionException ok) {
2322	>	checkCompletedWithWrappedCFException(h, ex);
2323	>	assertEquals(r.invocationCount, 0);
2324	>	}
2325	>
2326	>	checkCompletedWithWrappedCFException(f, ex);
2327	>	checkCompletedNormally(g, v1);
2328	>	}
2329		}
2330
2331		/**
2332		* acceptEither result completes exceptionally if action does
2333		*/
2334	<	public void testAcceptEither3() {
2335	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2336	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2337	<	FailingConsumer r = new FailingConsumer();
2338	<	CompletableFuture<Void> g = f.acceptEither(f2, r);
2339	<	f2.complete(two);
2340	<	checkCompletedWithWrappedCFException(g);
2334	>	public void testAcceptEither_actionFailed1() {
2335	>	for (ExecutionMode m : ExecutionMode.values())
2336	>	for (Integer v1 : new Integer[] { 1, null })
2337	>	for (Integer v2 : new Integer[] { 2, null }) {
2338	>
2339	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2340	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2341	>	final FailingConsumer r = new FailingConsumer();
2342	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2343	>
2344	>	f.complete(v1);
2345	>	checkCompletedWithWrappedCFException(h);
2346	>	g.complete(v2);
2347	>	checkCompletedNormally(f, v1);
2348	>	checkCompletedNormally(g, v2);
2349	>	}
2350	>	}
2351	>
2352	>	public void testAcceptEither_actionFailed2() {
2353	>	for (ExecutionMode m : ExecutionMode.values())
2354	>	for (Integer v1 : new Integer[] { 1, null })
2355	>	for (Integer v2 : new Integer[] { 2, null }) {
2356	>
2357	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2358	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2359	>	final FailingConsumer r = new FailingConsumer();
2360	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2361	>
2362	>	g.complete(v2);
2363	>	checkCompletedWithWrappedCFException(h);
2364	>	f.complete(v1);
2365	>	checkCompletedNormally(f, v1);
2366	>	checkCompletedNormally(g, v2);
2367	>	}
2368		}
2369
2370		/**
2371		* acceptEither result completes exceptionally if either source cancelled
2372		*/
2373	<	public void testAcceptEither4() {
2374	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2375	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2376	<	IncAction r = new IncAction();
2377	<	CompletableFuture<Void> g = f.acceptEither(f2, r);
2378	<	assertTrue(f.cancel(true));
2379	<	checkCompletedWithWrappedCancellationException(g);
2380	<	f = new CompletableFuture<Integer>();
2381	<	f2 = new CompletableFuture<Integer>();
2382	<	assertTrue(f2.cancel(true));
2383	<	checkCompletedWithWrappedCancellationException(g);
2373	>	public void testAcceptEither_sourceCancelled1() {
2374	>	for (ExecutionMode m : ExecutionMode.values())
2375	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2376	>	for (Integer v1 : new Integer[] { 1, null }) {
2377	>
2378	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2379	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2380	>	final IncAction r = new IncAction();
2381	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2382	>
2383	>	assertTrue(f.cancel(mayInterruptIfRunning));
2384	>	checkCompletedWithWrappedCancellationException(h);
2385	>	g.complete(v1);
2386	>
2387	>	checkCancelled(f);
2388	>	assertEquals(r.invocationCount, 0);
2389	>	checkCompletedNormally(g, v1);
2390	>	checkCompletedWithWrappedCancellationException(h);
2391	>	}
2392	>	}
2393	>
2394	>	public void testAcceptEither_sourceCancelled2() {
2395	>	for (ExecutionMode m : ExecutionMode.values())
2396	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2397	>	for (Integer v1 : new Integer[] { 1, null }) {
2398	>
2399	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2400	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2401	>	final IncAction r = new IncAction();
2402	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2403	>
2404	>	assertTrue(g.cancel(mayInterruptIfRunning));
2405	>	checkCompletedWithWrappedCancellationException(h);
2406	>	f.complete(v1);
2407	>
2408	>	checkCancelled(g);
2409	>	assertEquals(r.invocationCount, 0);
2410	>	checkCompletedNormally(f, v1);
2411	>	checkCompletedWithWrappedCancellationException(h);
2412	>	}
2413		}
2414
2415	+	public void testAcceptEither_sourceCancelled3() {
2416	+	for (ExecutionMode m : ExecutionMode.values())
2417	+	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2418	+	for (Integer v1 : new Integer[] { 1, null }) {
2419	+
2420	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
2421	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
2422	+	final IncAction r = new IncAction();
2423	+
2424	+	assertTrue(g.cancel(mayInterruptIfRunning));
2425	+	f.complete(v1);
2426	+	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2427	+
2428	+	// unspecified behavior
2429	+	Integer v;
2430	+	try {
2431	+	assertEquals(h.join(), null);
2432	+	assertEquals(r.invocationCount, 1);
2433	+	assertEquals(inc(v1), r.value);
2434	+	} catch (CompletionException ok) {
2435	+	checkCompletedWithWrappedCancellationException(h);
2436	+	assertEquals(r.invocationCount, 0);
2437	+	}
2438	+
2439	+	checkCancelled(g);
2440	+	checkCompletedNormally(f, v1);
2441	+	}
2442	+	}
2443	+
2444	+	public void testAcceptEither_sourceCancelled4() {
2445	+	for (ExecutionMode m : ExecutionMode.values())
2446	+	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2447	+	for (Integer v1 : new Integer[] { 1, null }) {
2448	+
2449	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
2450	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
2451	+	final IncAction r = new IncAction();
2452	+
2453	+	assertTrue(f.cancel(mayInterruptIfRunning));
2454	+	g.complete(v1);
2455	+	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2456	+
2457	+	// unspecified behavior
2458	+	Integer v;
2459	+	try {
2460	+	assertEquals(h.join(), null);
2461	+	assertEquals(r.invocationCount, 1);
2462	+	assertEquals(inc(v1), r.value);
2463	+	} catch (CompletionException ok) {
2464	+	checkCompletedWithWrappedCancellationException(h);
2465	+	assertEquals(r.invocationCount, 0);
2466	+	}
2467	+
2468	+	checkCancelled(f);
2469	+	checkCompletedNormally(g, v1);
2470	+	}
2471	+	}
2472
2473		/**
2474		* runAfterEither result completes normally after normal completion
2475		* of either source
2476		*/
2477	<	public void testRunAfterEither() {
2478	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2479	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2480	<	Noop r = new Noop();
2481	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2482	<	f.complete(one);
2483	<	checkCompletedNormally(g, null);
2484	<	f2.complete(one);
2485	<	checkCompletedNormally(g, null);
2486	<	assertTrue(r.ran);
2477	>	public void testRunAfterEither_normalCompletion1() {
2478	>	for (ExecutionMode m : ExecutionMode.values())
2479	>	for (Integer v1 : new Integer[] { 1, null })
2480	>	for (Integer v2 : new Integer[] { 2, null }) {
2481	>
2482	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2483	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2484	>	final Noop r = new Noop();
2485	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2486	>
2487	>	f.complete(v1);
2488	>	checkCompletedNormally(h, null);
2489	>	assertEquals(r.invocationCount, 1);
2490	>	g.complete(v2);
2491	>
2492	>	checkCompletedNormally(f, v1);
2493	>	checkCompletedNormally(g, v2);
2494	>	checkCompletedNormally(h, null);
2495	>	assertEquals(r.invocationCount, 1);
2496	>	}
2497	>	}
2498
2499	<	r = new Noop();
2500	<	f = new CompletableFuture<Integer>();
2501	<	f.complete(one);
2502	<	f2 = new CompletableFuture<Integer>();
2503	<	g = f.runAfterEither(f2, r);
2504	<	checkCompletedNormally(g, null);
2505	<	assertTrue(r.ran);
2499	>	public void testRunAfterEither_normalCompletion2() {
2500	>	for (ExecutionMode m : ExecutionMode.values())
2501	>	for (Integer v1 : new Integer[] { 1, null })
2502	>	for (Integer v2 : new Integer[] { 2, null }) {
2503	>
2504	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2505	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2506	>	final Noop r = new Noop();
2507	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2508	>
2509	>	g.complete(v2);
2510	>	checkCompletedNormally(h, null);
2511	>	assertEquals(r.invocationCount, 1);
2512	>	f.complete(v1);
2513	>
2514	>	checkCompletedNormally(f, v1);
2515	>	checkCompletedNormally(g, v2);
2516	>	checkCompletedNormally(h, null);
2517	>	assertEquals(r.invocationCount, 1);
2518	>	}
2519	>	}
2520	>	public void testRunAfterEither_normalCompletion3() {
2521	>	for (ExecutionMode m : ExecutionMode.values())
2522	>	for (Integer v1 : new Integer[] { 1, null })
2523	>	for (Integer v2 : new Integer[] { 2, null }) {
2524	>
2525	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2526	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2527	>	final Noop r = new Noop();
2528	>
2529	>	f.complete(v1);
2530	>	g.complete(v2);
2531	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2532	>
2533	>	checkCompletedNormally(h, null);
2534	>	checkCompletedNormally(f, v1);
2535	>	checkCompletedNormally(g, v2);
2536	>	assertEquals(r.invocationCount, 1);
2537	>	}
2538		}
2539
2540		/**
2541		* runAfterEither result completes exceptionally after exceptional
2542		* completion of either source
2543		*/
2544	<	public void testRunAfterEither2() {
2545	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2546	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2547	<	Noop r = new Noop();
2548	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2549	<	f.completeExceptionally(new CFException());
2550	<	f2.complete(one);
2551	<	checkCompletedWithWrappedCFException(g);
2544	>	public void testRunAfterEither_exceptionalCompletion1() {
2545	>	for (ExecutionMode m : ExecutionMode.values())
2546	>	for (Integer v1 : new Integer[] { 1, null }) {
2547	>
2548	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2549	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2550	>	final Noop r = new Noop();
2551	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2552	>	final CFException ex = new CFException();
2553	>
2554	>	f.completeExceptionally(ex);
2555	>	checkCompletedWithWrappedCFException(h, ex);
2556	>	g.complete(v1);
2557	>
2558	>	assertEquals(r.invocationCount, 0);
2559	>	checkCompletedNormally(g, v1);
2560	>	checkCompletedWithWrappedCFException(f, ex);
2561	>	checkCompletedWithWrappedCFException(h, ex);
2562	>	}
2563	>	}
2564
2565	<	r = new Noop();
2566	<	f = new CompletableFuture<Integer>();
2567	<	f2 = new CompletableFuture<Integer>();
2568	<	f2.completeExceptionally(new CFException());
2569	<	g = f.runAfterEither(f2, r);
2570	<	checkCompletedWithWrappedCFException(g);
2565	>	public void testRunAfterEither_exceptionalCompletion2() {
2566	>	for (ExecutionMode m : ExecutionMode.values())
2567	>	for (Integer v1 : new Integer[] { 1, null }) {
2568	>
2569	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2570	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2571	>	final Noop r = new Noop();
2572	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2573	>	final CFException ex = new CFException();
2574	>
2575	>	g.completeExceptionally(ex);
2576	>	checkCompletedWithWrappedCFException(h, ex);
2577	>	f.complete(v1);
2578	>
2579	>	assertEquals(r.invocationCount, 0);
2580	>	checkCompletedNormally(f, v1);
2581	>	checkCompletedWithWrappedCFException(g, ex);
2582	>	checkCompletedWithWrappedCFException(h, ex);
2583	>	}
2584	>	}
2585	>
2586	>	public void testRunAfterEither_exceptionalCompletion3() {
2587	>	for (ExecutionMode m : ExecutionMode.values())
2588	>	for (Integer v1 : new Integer[] { 1, null }) {
2589	>
2590	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2591	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2592	>	final Noop r = new Noop();
2593	>	final CFException ex = new CFException();
2594	>
2595	>	g.completeExceptionally(ex);
2596	>	f.complete(v1);
2597	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2598	>
2599	>	// unspecified behavior
2600	>	Integer v;
2601	>	try {
2602	>	assertEquals(h.join(), null);
2603	>	assertEquals(r.invocationCount, 1);
2604	>	} catch (CompletionException ok) {
2605	>	checkCompletedWithWrappedCFException(h, ex);
2606	>	assertEquals(r.invocationCount, 0);
2607	>	}
2608	>
2609	>	checkCompletedWithWrappedCFException(g, ex);
2610	>	checkCompletedNormally(f, v1);
2611	>	}
2612	>	}
2613	>
2614	>	public void testRunAfterEither_exceptionalCompletion4() {
2615	>	for (ExecutionMode m : ExecutionMode.values())
2616	>	for (Integer v1 : new Integer[] { 1, null }) {
2617	>
2618	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2619	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2620	>	final Noop r = new Noop();
2621	>	final CFException ex = new CFException();
2622	>
2623	>	f.completeExceptionally(ex);
2624	>	g.complete(v1);
2625	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2626	>
2627	>	// unspecified behavior
2628	>	Integer v;
2629	>	try {
2630	>	assertEquals(h.join(), null);
2631	>	assertEquals(r.invocationCount, 1);
2632	>	} catch (CompletionException ok) {
2633	>	checkCompletedWithWrappedCFException(h, ex);
2634	>	assertEquals(r.invocationCount, 0);
2635	>	}
2636	>
2637	>	checkCompletedWithWrappedCFException(f, ex);
2638	>	checkCompletedNormally(g, v1);
2639	>	}
2640		}
2641
2642		/**
2643		* runAfterEither result completes exceptionally if action does
2644		*/
2645	<	public void testRunAfterEither3() {
2646	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2647	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2648	<	FailingNoop r = new FailingNoop();
2649	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2650	<	f2.complete(two);
2651	<	checkCompletedWithWrappedCFException(g);
2645	>	public void testRunAfterEither_actionFailed1() {
2646	>	for (ExecutionMode m : ExecutionMode.values())
2647	>	for (Integer v1 : new Integer[] { 1, null })
2648	>	for (Integer v2 : new Integer[] { 2, null }) {
2649	>
2650	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2651	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2652	>	final FailingNoop r = new FailingNoop();
2653	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2654	>
2655	>	f.complete(v1);
2656	>	checkCompletedWithWrappedCFException(h);
2657	>	g.complete(v2);
2658	>	checkCompletedNormally(f, v1);
2659	>	checkCompletedNormally(g, v2);
2660	>	}
2661	>	}
2662	>
2663	>	public void testRunAfterEither_actionFailed2() {
2664	>	for (ExecutionMode m : ExecutionMode.values())
2665	>	for (Integer v1 : new Integer[] { 1, null })
2666	>	for (Integer v2 : new Integer[] { 2, null }) {
2667	>
2668	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2669	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2670	>	final FailingNoop r = new FailingNoop();
2671	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2672	>
2673	>	g.complete(v2);
2674	>	checkCompletedWithWrappedCFException(h);
2675	>	f.complete(v1);
2676	>	checkCompletedNormally(f, v1);
2677	>	checkCompletedNormally(g, v2);
2678	>	}
2679		}
2680
2681		/**
2682		* runAfterEither result completes exceptionally if either source cancelled
2683		*/
2684	<	public void testRunAfterEither4() {
2685	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2686	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2687	<	Noop r = new Noop();
2688	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2689	<	assertTrue(f.cancel(true));
2690	<	checkCompletedWithWrappedCancellationException(g);
2691	<	f = new CompletableFuture<Integer>();
2692	<	f2 = new CompletableFuture<Integer>();
2693	<	assertTrue(f2.cancel(true));
2694	<	checkCompletedWithWrappedCancellationException(g);
2684	>	public void testRunAfterEither_sourceCancelled1() {
2685	>	for (ExecutionMode m : ExecutionMode.values())
2686	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2687	>	for (Integer v1 : new Integer[] { 1, null }) {
2688	>
2689	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2690	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2691	>	final Noop r = new Noop();
2692	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2693	>
2694	>	assertTrue(f.cancel(mayInterruptIfRunning));
2695	>	checkCompletedWithWrappedCancellationException(h);
2696	>	g.complete(v1);
2697	>
2698	>	checkCancelled(f);
2699	>	assertEquals(r.invocationCount, 0);
2700	>	checkCompletedNormally(g, v1);
2701	>	checkCompletedWithWrappedCancellationException(h);
2702	>	}
2703	>	}
2704	>
2705	>	public void testRunAfterEither_sourceCancelled2() {
2706	>	for (ExecutionMode m : ExecutionMode.values())
2707	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2708	>	for (Integer v1 : new Integer[] { 1, null }) {
2709	>
2710	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2711	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2712	>	final Noop r = new Noop();
2713	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2714	>
2715	>	assertTrue(g.cancel(mayInterruptIfRunning));
2716	>	checkCompletedWithWrappedCancellationException(h);
2717	>	f.complete(v1);
2718	>
2719	>	checkCancelled(g);
2720	>	assertEquals(r.invocationCount, 0);
2721	>	checkCompletedNormally(f, v1);
2722	>	checkCompletedWithWrappedCancellationException(h);
2723	>	}
2724	>	}
2725	>
2726	>	public void testRunAfterEither_sourceCancelled3() {
2727	>	for (ExecutionMode m : ExecutionMode.values())
2728	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2729	>	for (Integer v1 : new Integer[] { 1, null }) {
2730	>
2731	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2732	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2733	>	final Noop r = new Noop();
2734	>
2735	>	assertTrue(g.cancel(mayInterruptIfRunning));
2736	>	f.complete(v1);
2737	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2738	>
2739	>	// unspecified behavior
2740	>	Integer v;
2741	>	try {
2742	>	assertEquals(h.join(), null);
2743	>	assertEquals(r.invocationCount, 1);
2744	>	} catch (CompletionException ok) {
2745	>	checkCompletedWithWrappedCancellationException(h);
2746	>	assertEquals(r.invocationCount, 0);
2747	>	}
2748	>
2749	>	checkCancelled(g);
2750	>	checkCompletedNormally(f, v1);
2751	>	}
2752	>	}
2753	>
2754	>	public void testRunAfterEither_sourceCancelled4() {
2755	>	for (ExecutionMode m : ExecutionMode.values())
2756	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2757	>	for (Integer v1 : new Integer[] { 1, null }) {
2758	>
2759	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2760	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2761	>	final Noop r = new Noop();
2762	>
2763	>	assertTrue(f.cancel(mayInterruptIfRunning));
2764	>	g.complete(v1);
2765	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2766	>
2767	>	// unspecified behavior
2768	>	Integer v;
2769	>	try {
2770	>	assertEquals(h.join(), null);
2771	>	assertEquals(r.invocationCount, 1);
2772	>	} catch (CompletionException ok) {
2773	>	checkCompletedWithWrappedCancellationException(h);
2774	>	assertEquals(r.invocationCount, 0);
2775	>	}
2776	>
2777	>	checkCancelled(f);
2778	>	checkCompletedNormally(g, v1);
2779	>	}
2780		}
2781
2782		/**
2783		* thenCompose result completes normally after normal completion of source
2784		*/
2785		public void testThenCompose() {
2786	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2787	<	CompletableFutureInc r = new CompletableFutureInc();
2788	<	CompletableFuture<Integer> g = f.thenCompose(r);
2786	>	CompletableFuture<Integer> f, g;
2787	>	CompletableFutureInc r;
2788	>
2789	>	f = new CompletableFuture<>();
2790	>	g = f.thenCompose(r = new CompletableFutureInc());
2791		f.complete(one);
2792		checkCompletedNormally(g, two);
2793	+	assertTrue(r.ran);
2794	+
2795	+	f = new CompletableFuture<>();
2796	+	f.complete(one);
2797	+	g = f.thenCompose(r = new CompletableFutureInc());
2798	+	checkCompletedNormally(g, two);
2799	+	assertTrue(r.ran);
2800		}
2801
2802		/**
#	Line 1058 | Line 2804 | public class CompletableFutureTest exten
2804		* completion of source
2805		*/
2806		public void testThenCompose2() {
2807	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2808	<	CompletableFutureInc r = new CompletableFutureInc();
2809	<	CompletableFuture<Integer> g = f.thenCompose(r);
2807	>	CompletableFuture<Integer> f, g;
2808	>	CompletableFutureInc r;
2809	>
2810	>	f = new CompletableFuture<>();
2811	>	g = f.thenCompose(r = new CompletableFutureInc());
2812	>	f.completeExceptionally(new CFException());
2813	>	checkCompletedWithWrappedCFException(g);
2814	>
2815	>	f = new CompletableFuture<>();
2816		f.completeExceptionally(new CFException());
2817	+	g = f.thenCompose(r = new CompletableFutureInc());
2818		checkCompletedWithWrappedCFException(g);
2819		}
2820
#	Line 1069 | Line 2822 | public class CompletableFutureTest exten
2822		* thenCompose result completes exceptionally if action does
2823		*/
2824		public void testThenCompose3() {
2825	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2826	<	FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
2827	<	CompletableFuture<Integer> g = f.thenCompose(r);
2825	>	CompletableFuture<Integer> f, g;
2826	>	FailingCompletableFutureFunction r;
2827	>
2828	>	f = new CompletableFuture<>();
2829	>	g = f.thenCompose(r = new FailingCompletableFutureFunction());
2830		f.complete(one);
2831		checkCompletedWithWrappedCFException(g);
2832	+
2833	+	f = new CompletableFuture<>();
2834	+	f.complete(one);
2835	+	g = f.thenCompose(r = new FailingCompletableFutureFunction());
2836	+	checkCompletedWithWrappedCFException(g);
2837		}
2838
2839		/**
2840		* thenCompose result completes exceptionally if source cancelled
2841		*/
2842		public void testThenCompose4() {
2843	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2844	<	CompletableFutureInc r = new CompletableFutureInc();
2845	<	CompletableFuture<Integer> g = f.thenCompose(r);
2843	>	CompletableFuture<Integer> f, g;
2844	>	CompletableFutureInc r;
2845	>
2846	>	f = new CompletableFuture<>();
2847	>	g = f.thenCompose(r = new CompletableFutureInc());
2848		assertTrue(f.cancel(true));
2849		checkCompletedWithWrappedCancellationException(g);
1088	–	}
2850
2851	+	f = new CompletableFuture<>();
2852	+	assertTrue(f.cancel(true));
2853	+	g = f.thenCompose(r = new CompletableFutureInc());
2854	+	checkCompletedWithWrappedCancellationException(g);
2855	+	}
2856
2857		// asyncs
2858
#	Line 1094 | Line 2860 | public class CompletableFutureTest exten
2860		* thenRunAsync result completes normally after normal completion of source
2861		*/
2862		public void testThenRunAsync() {
2863	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2863	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2864		Noop r = new Noop();
2865		CompletableFuture<Void> g = f.thenRunAsync(r);
2866		f.complete(null);
2867		checkCompletedNormally(g, null);
2868
2869		// reordered version
2870	<	f = new CompletableFuture<Integer>();
2870	>	f = new CompletableFuture<>();
2871		f.complete(null);
2872		r = new Noop();
2873		g = f.thenRunAsync(r);
#	Line 1113 | Line 2879 | public class CompletableFutureTest exten
2879		* completion of source
2880		*/
2881		public void testThenRunAsync2() {
2882	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2882	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2883		Noop r = new Noop();
2884		CompletableFuture<Void> g = f.thenRunAsync(r);
2885		f.completeExceptionally(new CFException());
2886		try {
2887		g.join();
2888		shouldThrow();
2889	<	} catch (Exception ok) {
1124	<	}
2889	>	} catch (CompletionException success) {}
2890		checkCompletedWithWrappedCFException(g);
2891		}
2892
#	Line 1129 | Line 2894 | public class CompletableFutureTest exten
2894		* thenRunAsync result completes exceptionally if action does
2895		*/
2896		public void testThenRunAsync3() {
2897	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2897	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2898		FailingNoop r = new FailingNoop();
2899		CompletableFuture<Void> g = f.thenRunAsync(r);
2900		f.complete(null);
#	Line 1140 | Line 2905 | public class CompletableFutureTest exten
2905		* thenRunAsync result completes exceptionally if source cancelled
2906		*/
2907		public void testThenRunAsync4() {
2908	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2908	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2909		Noop r = new Noop();
2910		CompletableFuture<Void> g = f.thenRunAsync(r);
2911		assertTrue(f.cancel(true));
#	Line 1151 | Line 2916 | public class CompletableFutureTest exten
2916		* thenApplyAsync result completes normally after normal completion of source
2917		*/
2918		public void testThenApplyAsync() {
2919	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2919	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2920		CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2921		f.complete(one);
2922		checkCompletedNormally(g, two);
#	Line 1162 | Line 2927 | public class CompletableFutureTest exten
2927		* completion of source
2928		*/
2929		public void testThenApplyAsync2() {
2930	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2930	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2931		CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2932		f.completeExceptionally(new CFException());
2933		checkCompletedWithWrappedCFException(g);
#	Line 1172 | Line 2937 | public class CompletableFutureTest exten
2937		* thenApplyAsync result completes exceptionally if action does
2938		*/
2939		public void testThenApplyAsync3() {
2940	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2940	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2941		FailingFunction r = new FailingFunction();
2942		CompletableFuture<Integer> g = f.thenApplyAsync(r);
2943		f.complete(null);
#	Line 1183 | Line 2948 | public class CompletableFutureTest exten
2948		* thenApplyAsync result completes exceptionally if source cancelled
2949		*/
2950		public void testThenApplyAsync4() {
2951	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2951	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2952		CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2953		assertTrue(f.cancel(true));
2954		checkCompletedWithWrappedCancellationException(g);
#	Line 1194 | Line 2959 | public class CompletableFutureTest exten
2959		* completion of source
2960		*/
2961		public void testThenAcceptAsync() {
2962	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2962	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2963		IncAction r = new IncAction();
2964		CompletableFuture<Void> g = f.thenAcceptAsync(r);
2965		f.complete(one);
2966		checkCompletedNormally(g, null);
2967	<	assertEquals(r.value, 2);
2967	>	assertEquals(r.value, (Integer) 2);
2968		}
2969
2970		/**
#	Line 1207 | Line 2972 | public class CompletableFutureTest exten
2972		* completion of source
2973		*/
2974		public void testThenAcceptAsync2() {
2975	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2975	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2976		IncAction r = new IncAction();
2977		CompletableFuture<Void> g = f.thenAcceptAsync(r);
2978		f.completeExceptionally(new CFException());
#	Line 1218 | Line 2983 | public class CompletableFutureTest exten
2983		* thenAcceptAsync result completes exceptionally if action does
2984		*/
2985		public void testThenAcceptAsync3() {
2986	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2986	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2987		FailingConsumer r = new FailingConsumer();
2988		CompletableFuture<Void> g = f.thenAcceptAsync(r);
2989		f.complete(null);
#	Line 1229 | Line 2994 | public class CompletableFutureTest exten
2994		* thenAcceptAsync result completes exceptionally if source cancelled
2995		*/
2996		public void testThenAcceptAsync4() {
2997	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2997	>	CompletableFuture<Integer> f = new CompletableFuture<>();
2998		IncAction r = new IncAction();
2999		CompletableFuture<Void> g = f.thenAcceptAsync(r);
3000		assertTrue(f.cancel(true));
3001		checkCompletedWithWrappedCancellationException(g);
3002		}
1238	–	/**
1239	–	* thenCombineAsync result completes normally after normal
1240	–	* completion of sources
1241	–	*/
1242	–	public void testThenCombineAsync() {
1243	–	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1244	–	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1245	–	CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1246	–	f.complete(one);
1247	–	checkIncomplete(g);
1248	–	f2.complete(two);
1249	–	checkCompletedNormally(g, three);
1250	–	}
3003
3004		/**
3005	<	* thenCombineAsync result completes exceptionally after exceptional
1254	<	* completion of source
1255	<	*/
1256	<	public void testThenCombineAsync2() {
1257	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1258	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1259	<	CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1260	<	f.completeExceptionally(new CFException());
1261	<	f2.complete(two);
1262	<	checkCompletedWithWrappedCFException(g);
1263	<
1264	<	f = new CompletableFuture<Integer>();
1265	<	f2 = new CompletableFuture<Integer>();
1266	<	g = f.thenCombineAsync(f2, add);
1267	<	f.complete(one);
1268	<	f2.completeExceptionally(new CFException());
1269	<	checkCompletedWithWrappedCFException(g);
1270	<	}
1271	<
1272	<	/**
1273	<	* thenCombineAsync result completes exceptionally if action does
1274	<	*/
1275	<	public void testThenCombineAsync3() {
1276	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1277	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1278	<	FailingBiFunction r = new FailingBiFunction();
1279	<	CompletableFuture<Integer> g = f.thenCombineAsync(f2, r);
1280	<	f.complete(one);
1281	<	checkIncomplete(g);
1282	<	f2.complete(two);
1283	<	checkCompletedWithWrappedCFException(g);
1284	<	}
1285	<
1286	<	/**
1287	<	* thenCombineAsync result completes exceptionally if either source cancelled
1288	<	*/
1289	<	public void testThenCombineAsync4() {
1290	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1291	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1292	<	CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1293	<	assertTrue(f.cancel(true));
1294	<	f2.complete(two);
1295	<	checkCompletedWithWrappedCancellationException(g);
1296	<
1297	<	f = new CompletableFuture<Integer>();
1298	<	f2 = new CompletableFuture<Integer>();
1299	<	g = f.thenCombineAsync(f2, add);
1300	<	f.complete(one);
1301	<	assertTrue(f2.cancel(true));
1302	<	checkCompletedWithWrappedCancellationException(g);
1303	<	}
1304	<
1305	<	/**
1306	<	* thenAcceptBothAsync result completes normally after normal
1307	<	* completion of sources
1308	<	*/
1309	<	public void testThenAcceptBothAsync() {
1310	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1311	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1312	<	AddAction r = new AddAction();
1313	<	CompletableFuture<Void> g = f.thenAcceptBothAsync(f2, r);
1314	<	f.complete(one);
1315	<	checkIncomplete(g);
1316	<	f2.complete(two);
1317	<	checkCompletedNormally(g, null);
1318	<	assertEquals(r.value, 3);
1319	<	}
1320	<
1321	<	/**
1322	<	* thenAcceptBothAsync result completes exceptionally after exceptional
1323	<	* completion of source
1324	<	*/
1325	<	public void testThenAcceptBothAsync2() {
1326	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1327	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1328	<	AddAction r = new AddAction();
1329	<	CompletableFuture<Void> g = f.thenAcceptBothAsync(f2, r);
1330	<	f.completeExceptionally(new CFException());
1331	<	f2.complete(two);
1332	<	checkCompletedWithWrappedCFException(g);
1333	<
1334	<	r = new AddAction();
1335	<	f = new CompletableFuture<Integer>();
1336	<	f2 = new CompletableFuture<Integer>();
1337	<	g = f.thenAcceptBothAsync(f2, r);
1338	<	f.complete(one);
1339	<	f2.completeExceptionally(new CFException());
1340	<	checkCompletedWithWrappedCFException(g);
1341	<	}
1342	<
1343	<	/**
1344	<	* thenAcceptBothAsync result completes exceptionally if action does
1345	<	*/
1346	<	public void testThenAcceptBothAsync3() {
1347	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1348	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1349	<	FailingBiConsumer r = new FailingBiConsumer();
1350	<	CompletableFuture<Void> g = f.thenAcceptBothAsync(f2, r);
1351	<	f.complete(one);
1352	<	checkIncomplete(g);
1353	<	f2.complete(two);
1354	<	checkCompletedWithWrappedCFException(g);
1355	<	}
1356	<
1357	<	/**
1358	<	* thenAcceptBothAsync result completes exceptionally if either source cancelled
1359	<	*/
1360	<	public void testThenAcceptBothAsync4() {
1361	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1362	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1363	<	AddAction r = new AddAction();
1364	<	CompletableFuture<Void> g = f.thenAcceptBothAsync(f2, r);
1365	<	assertTrue(f.cancel(true));
1366	<	f2.complete(two);
1367	<	checkCompletedWithWrappedCancellationException(g);
1368	<
1369	<	r = new AddAction();
1370	<	f = new CompletableFuture<Integer>();
1371	<	f2 = new CompletableFuture<Integer>();
1372	<	g = f.thenAcceptBothAsync(f2, r);
1373	<	f.complete(one);
1374	<	assertTrue(f2.cancel(true));
1375	<	checkCompletedWithWrappedCancellationException(g);
1376	<	}
1377	<
1378	<	/**
1379	<	* runAfterBothAsync result completes normally after normal
1380	<	* completion of sources
1381	<	*/
1382	<	public void testRunAfterBothAsync() {
1383	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1384	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1385	<	Noop r = new Noop();
1386	<	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1387	<	f.complete(one);
1388	<	checkIncomplete(g);
1389	<	f2.complete(two);
1390	<	checkCompletedNormally(g, null);
1391	<	assertTrue(r.ran);
1392	<	}
1393	<
1394	<	/**
1395	<	* runAfterBothAsync result completes exceptionally after exceptional
3005	>	* thenComposeAsync result completes normally after normal
3006		* completion of source
3007		*/
3008	<	public void testRunAfterBothAsync2() {
3009	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3010	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1401	<	Noop r = new Noop();
1402	<	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1403	<	f.completeExceptionally(new CFException());
1404	<	f2.complete(two);
1405	<	checkCompletedWithWrappedCFException(g);
1406	<
1407	<	r = new Noop();
1408	<	f = new CompletableFuture<Integer>();
1409	<	f2 = new CompletableFuture<Integer>();
1410	<	g = f.runAfterBothAsync(f2, r);
1411	<	f.complete(one);
1412	<	f2.completeExceptionally(new CFException());
1413	<	checkCompletedWithWrappedCFException(g);
1414	<	}
1415	<
1416	<	/**
1417	<	* runAfterBothAsync result completes exceptionally if action does
1418	<	*/
1419	<	public void testRunAfterBothAsync3() {
1420	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1421	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1422	<	FailingNoop r = new FailingNoop();
1423	<	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1424	<	f.complete(one);
1425	<	checkIncomplete(g);
1426	<	f2.complete(two);
1427	<	checkCompletedWithWrappedCFException(g);
1428	<	}
1429	<
1430	<	/**
1431	<	* runAfterBothAsync result completes exceptionally if either source cancelled
1432	<	*/
1433	<	public void testRunAfterBothAsync4() {
1434	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1435	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1436	<	Noop r = new Noop();
1437	<	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1438	<	assertTrue(f.cancel(true));
1439	<	f2.complete(two);
1440	<	checkCompletedWithWrappedCancellationException(g);
1441	<
1442	<	r = new Noop();
1443	<	f = new CompletableFuture<Integer>();
1444	<	f2 = new CompletableFuture<Integer>();
1445	<	g = f.runAfterBothAsync(f2, r);
1446	<	f.complete(one);
1447	<	assertTrue(f2.cancel(true));
1448	<	checkCompletedWithWrappedCancellationException(g);
1449	<	}
3008	>	public void testThenComposeAsync() {
3009	>	CompletableFuture<Integer> f, g;
3010	>	CompletableFutureInc r;
3011
3012	<	/**
3013	<	* applyToEitherAsync result completes normally after normal
1453	<	* completion of sources
1454	<	*/
1455	<	public void testApplyToEitherAsync() {
1456	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1457	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1458	<	CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
3012	>	f = new CompletableFuture<>();
3013	>	g = f.thenComposeAsync(r = new CompletableFutureInc());
3014		f.complete(one);
3015		checkCompletedNormally(g, two);
3016
3017	<	f = new CompletableFuture<Integer>();
3017	>	f = new CompletableFuture<>();
3018		f.complete(one);
3019	<	f2 = new CompletableFuture<Integer>();
1465	<	g = f.applyToEitherAsync(f2, inc);
3019	>	g = f.thenComposeAsync(r = new CompletableFutureInc());
3020		checkCompletedNormally(g, two);
3021		}
3022
3023		/**
3024	<	* applyToEitherAsync result completes exceptionally after exceptional
3025	<	* completion of source
1472	<	*/
1473	<	public void testApplyToEitherAsync2() {
1474	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1475	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1476	<	CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
1477	<	f.completeExceptionally(new CFException());
1478	<	checkCompletedWithWrappedCFException(g);
1479	<
1480	<	f = new CompletableFuture<Integer>();
1481	<	f2 = new CompletableFuture<Integer>();
1482	<	f2.completeExceptionally(new CFException());
1483	<	g = f.applyToEitherAsync(f2, inc);
1484	<	f.complete(one);
1485	<	checkCompletedWithWrappedCFException(g);
1486	<	}
1487	<
1488	<	/**
1489	<	* applyToEitherAsync result completes exceptionally if action does
1490	<	*/
1491	<	public void testApplyToEitherAsync3() {
1492	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1493	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1494	<	FailingFunction r = new FailingFunction();
1495	<	CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r);
1496	<	f.complete(one);
1497	<	checkCompletedWithWrappedCFException(g);
1498	<	}
1499	<
1500	<	/**
1501	<	* applyToEitherAsync result completes exceptionally if either source cancelled
1502	<	*/
1503	<	public void testApplyToEitherAsync4() {
1504	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1505	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1506	<	CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
1507	<	assertTrue(f.cancel(true));
1508	<	checkCompletedWithWrappedCancellationException(g);
1509	<
1510	<	f = new CompletableFuture<Integer>();
1511	<	f2 = new CompletableFuture<Integer>();
1512	<	assertTrue(f2.cancel(true));
1513	<	g = f.applyToEitherAsync(f2, inc);
1514	<	checkCompletedWithWrappedCancellationException(g);
1515	<	}
1516	<
1517	<	/**
1518	<	* acceptEitherAsync result completes normally after normal
1519	<	* completion of sources
3024	>	* thenComposeAsync result completes exceptionally after
3025	>	* exceptional completion of source
3026		*/
3027	<	public void testAcceptEitherAsync() {
3028	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3029	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1524	<	IncAction r = new IncAction();
1525	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1526	<	f.complete(one);
1527	<	checkCompletedNormally(g, null);
1528	<	assertEquals(r.value, 2);
1529	<
1530	<	r = new IncAction();
1531	<	f = new CompletableFuture<Integer>();
1532	<	f.complete(one);
1533	<	f2 = new CompletableFuture<Integer>();
1534	<	g = f.acceptEitherAsync(f2, r);
1535	<	checkCompletedNormally(g, null);
1536	<	assertEquals(r.value, 2);
1537	<	}
3027	>	public void testThenComposeAsync2() {
3028	>	CompletableFuture<Integer> f, g;
3029	>	CompletableFutureInc r;
3030
3031	<	/**
3032	<	* acceptEitherAsync result completes exceptionally after exceptional
1541	<	* completion of source
1542	<	*/
1543	<	public void testAcceptEitherAsync2() {
1544	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1545	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1546	<	IncAction r = new IncAction();
1547	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
3031	>	f = new CompletableFuture<>();
3032	>	g = f.thenComposeAsync(r = new CompletableFutureInc());
3033		f.completeExceptionally(new CFException());
3034		checkCompletedWithWrappedCFException(g);
3035	+	assertFalse(r.ran);
3036
3037	<	r = new IncAction();
3038	<	f = new CompletableFuture<Integer>();
3039	<	f2 = new CompletableFuture<Integer>();
1554	<	f2.completeExceptionally(new CFException());
1555	<	g = f.acceptEitherAsync(f2, r);
1556	<	f.complete(one);
1557	<	checkCompletedWithWrappedCFException(g);
1558	<	}
1559	<
1560	<	/**
1561	<	* acceptEitherAsync result completes exceptionally if action does
1562	<	*/
1563	<	public void testAcceptEitherAsync3() {
1564	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1565	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1566	<	FailingConsumer r = new FailingConsumer();
1567	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1568	<	f.complete(one);
3037	>	f = new CompletableFuture<>();
3038	>	f.completeExceptionally(new CFException());
3039	>	g = f.thenComposeAsync(r = new CompletableFutureInc());
3040		checkCompletedWithWrappedCFException(g);
3041	+	assertFalse(r.ran);
3042		}
3043
3044		/**
3045	<	* acceptEitherAsync result completes exceptionally if either
1574	<	* source cancelled
1575	<	*/
1576	<	public void testAcceptEitherAsync4() {
1577	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1578	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1579	<	IncAction r = new IncAction();
1580	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
1581	<	assertTrue(f.cancel(true));
1582	<	checkCompletedWithWrappedCancellationException(g);
1583	<
1584	<	r = new IncAction();
1585	<	f = new CompletableFuture<Integer>();
1586	<	f2 = new CompletableFuture<Integer>();
1587	<	assertTrue(f2.cancel(true));
1588	<	g = f.acceptEitherAsync(f2, r);
1589	<	checkCompletedWithWrappedCancellationException(g);
1590	<	}
1591	<
1592	<	/**
1593	<	* runAfterEitherAsync result completes normally after normal
1594	<	* completion of sources
3045	>	* thenComposeAsync result completes exceptionally if action does
3046		*/
3047	<	public void testRunAfterEitherAsync() {
3048	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3049	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1599	<	Noop r = new Noop();
1600	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1601	<	f.complete(one);
1602	<	checkCompletedNormally(g, null);
1603	<	assertTrue(r.ran);
3047	>	public void testThenComposeAsync3() {
3048	>	CompletableFuture<Integer> f, g;
3049	>	FailingCompletableFutureFunction r;
3050
3051	<	r = new Noop();
3052	<	f = new CompletableFuture<Integer>();
3051	>	f = new CompletableFuture<>();
3052	>	g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
3053		f.complete(one);
1608	–	f2 = new CompletableFuture<Integer>();
1609	–	g = f.runAfterEitherAsync(f2, r);
1610	–	checkCompletedNormally(g, null);
1611	–	assertTrue(r.ran);
1612	–	}
1613	–
1614	–	/**
1615	–	* runAfterEitherAsync result completes exceptionally after exceptional
1616	–	* completion of source
1617	–	*/
1618	–	public void testRunAfterEitherAsync2() {
1619	–	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1620	–	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1621	–	Noop r = new Noop();
1622	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1623	–	f.completeExceptionally(new CFException());
3054		checkCompletedWithWrappedCFException(g);
3055
3056	<	r = new Noop();
1627	<	f = new CompletableFuture<Integer>();
1628	<	f2 = new CompletableFuture<Integer>();
1629	<	f2.completeExceptionally(new CFException());
1630	<	g = f.runAfterEitherAsync(f2, r);
3056	>	f = new CompletableFuture<>();
3057		f.complete(one);
3058	+	g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
3059		checkCompletedWithWrappedCFException(g);
3060		}
3061
3062		/**
3063	<	* runAfterEitherAsync result completes exceptionally if action does
3063	>	* thenComposeAsync result completes exceptionally if source cancelled
3064		*/
3065	<	public void testRunAfterEitherAsync3() {
3066	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3067	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1641	<	FailingNoop r = new FailingNoop();
1642	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
1643	<	f.complete(one);
1644	<	checkCompletedWithWrappedCFException(g);
1645	<	}
3065	>	public void testThenComposeAsync4() {
3066	>	CompletableFuture<Integer> f, g;
3067	>	CompletableFutureInc r;
3068
3069	<	/**
3070	<	* runAfterEitherAsync result completes exceptionally if either
1649	<	* source cancelled
1650	<	*/
1651	<	public void testRunAfterEitherAsync4() {
1652	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1653	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1654	<	Noop r = new Noop();
1655	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
3069	>	f = new CompletableFuture<>();
3070	>	g = f.thenComposeAsync(r = new CompletableFutureInc());
3071		assertTrue(f.cancel(true));
3072		checkCompletedWithWrappedCancellationException(g);
3073
3074	<	r = new Noop();
1660	<	f = new CompletableFuture<Integer>();
1661	<	f2 = new CompletableFuture<Integer>();
1662	<	assertTrue(f2.cancel(true));
1663	<	g = f.runAfterEitherAsync(f2, r);
1664	<	checkCompletedWithWrappedCancellationException(g);
1665	<	}
1666	<
1667	<	/**
1668	<	* thenComposeAsync result completes normally after normal
1669	<	* completion of source
1670	<	*/
1671	<	public void testThenComposeAsync() {
1672	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1673	<	CompletableFutureInc r = new CompletableFutureInc();
1674	<	CompletableFuture<Integer> g = f.thenComposeAsync(r);
1675	<	f.complete(one);
1676	<	checkCompletedNormally(g, two);
1677	<	}
1678	<
1679	<	/**
1680	<	* thenComposeAsync result completes exceptionally after
1681	<	* exceptional completion of source
1682	<	*/
1683	<	public void testThenComposeAsync2() {
1684	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1685	<	CompletableFutureInc r = new CompletableFutureInc();
1686	<	CompletableFuture<Integer> g = f.thenComposeAsync(r);
1687	<	f.completeExceptionally(new CFException());
1688	<	checkCompletedWithWrappedCFException(g);
1689	<	}
1690	<
1691	<	/**
1692	<	* thenComposeAsync result completes exceptionally if action does
1693	<	*/
1694	<	public void testThenComposeAsync3() {
1695	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1696	<	FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
1697	<	CompletableFuture<Integer> g = f.thenComposeAsync(r);
1698	<	f.complete(one);
1699	<	checkCompletedWithWrappedCFException(g);
1700	<	}
1701	<
1702	<	/**
1703	<	* thenComposeAsync result completes exceptionally if source cancelled
1704	<	*/
1705	<	public void testThenComposeAsync4() {
1706	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1707	<	CompletableFutureInc r = new CompletableFutureInc();
1708	<	CompletableFuture<Integer> g = f.thenComposeAsync(r);
3074	>	f = new CompletableFuture<>();
3075		assertTrue(f.cancel(true));
3076	+	g = f.thenComposeAsync(r = new CompletableFutureInc());
3077		checkCompletedWithWrappedCancellationException(g);
3078		}
3079
1713	–
3080		// async with explicit executors
3081
3082		/**
3083		* thenRunAsync result completes normally after normal completion of source
3084		*/
3085		public void testThenRunAsyncE() {
3086	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3086	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3087		Noop r = new Noop();
3088		CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3089		f.complete(null);
3090		checkCompletedNormally(g, null);
3091
3092		// reordered version
3093	<	f = new CompletableFuture<Integer>();
3093	>	f = new CompletableFuture<>();
3094		f.complete(null);
3095		r = new Noop();
3096		g = f.thenRunAsync(r, new ThreadExecutor());
#	Line 1736 | Line 3102 | public class CompletableFutureTest exten
3102		* completion of source
3103		*/
3104		public void testThenRunAsync2E() {
3105	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3105	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3106		Noop r = new Noop();
3107		CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3108		f.completeExceptionally(new CFException());
3109		try {
3110		g.join();
3111		shouldThrow();
3112	<	} catch (Exception ok) {
1747	<	}
3112	>	} catch (CompletionException success) {}
3113		checkCompletedWithWrappedCFException(g);
3114		}
3115
#	Line 1752 | Line 3117 | public class CompletableFutureTest exten
3117		* thenRunAsync result completes exceptionally if action does
3118		*/
3119		public void testThenRunAsync3E() {
3120	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3120	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3121		FailingNoop r = new FailingNoop();
3122		CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3123		f.complete(null);
#	Line 1763 | Line 3128 | public class CompletableFutureTest exten
3128		* thenRunAsync result completes exceptionally if source cancelled
3129		*/
3130		public void testThenRunAsync4E() {
3131	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3131	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3132		Noop r = new Noop();
3133		CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3134		assertTrue(f.cancel(true));
#	Line 1774 | Line 3139 | public class CompletableFutureTest exten
3139		* thenApplyAsync result completes normally after normal completion of source
3140		*/
3141		public void testThenApplyAsyncE() {
3142	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3142	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3143		CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3144		f.complete(one);
3145		checkCompletedNormally(g, two);
#	Line 1785 | Line 3150 | public class CompletableFutureTest exten
3150		* completion of source
3151		*/
3152		public void testThenApplyAsync2E() {
3153	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3153	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3154		CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3155		f.completeExceptionally(new CFException());
3156		checkCompletedWithWrappedCFException(g);
#	Line 1795 | Line 3160 | public class CompletableFutureTest exten
3160		* thenApplyAsync result completes exceptionally if action does
3161		*/
3162		public void testThenApplyAsync3E() {
3163	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3163	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3164		FailingFunction r = new FailingFunction();
3165		CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
3166		f.complete(null);
#	Line 1806 | Line 3171 | public class CompletableFutureTest exten
3171		* thenApplyAsync result completes exceptionally if source cancelled
3172		*/
3173		public void testThenApplyAsync4E() {
3174	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3174	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3175		CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3176		assertTrue(f.cancel(true));
3177		checkCompletedWithWrappedCancellationException(g);
#	Line 1817 | Line 3182 | public class CompletableFutureTest exten
3182		* completion of source
3183		*/
3184		public void testThenAcceptAsyncE() {
3185	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3185	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3186		IncAction r = new IncAction();
3187		CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3188		f.complete(one);
3189		checkCompletedNormally(g, null);
3190	<	assertEquals(r.value, 2);
3190	>	assertEquals(r.value, (Integer) 2);
3191		}
3192
3193		/**
#	Line 1830 | Line 3195 | public class CompletableFutureTest exten
3195		* completion of source
3196		*/
3197		public void testThenAcceptAsync2E() {
3198	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3198	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3199		IncAction r = new IncAction();
3200		CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3201		f.completeExceptionally(new CFException());
#	Line 1841 | Line 3206 | public class CompletableFutureTest exten
3206		* thenAcceptAsync result completes exceptionally if action does
3207		*/
3208		public void testThenAcceptAsync3E() {
3209	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3209	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3210		FailingConsumer r = new FailingConsumer();
3211		CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3212		f.complete(null);
#	Line 1852 | Line 3217 | public class CompletableFutureTest exten
3217		* thenAcceptAsync result completes exceptionally if source cancelled
3218		*/
3219		public void testThenAcceptAsync4E() {
3220	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3220	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3221		IncAction r = new IncAction();
3222		CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3223		assertTrue(f.cancel(true));
3224		checkCompletedWithWrappedCancellationException(g);
3225		}
3226	+
3227		/**
3228	<	* thenCombineAsync result completes normally after normal
3229	<	* completion of sources
3228	>	* thenComposeAsync result completes normally after normal
3229	>	* completion of source
3230		*/
3231	<	public void testThenCombineAsyncE() {
3232	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3233	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3234	<	CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
3231	>	public void testThenComposeAsyncE() {
3232	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3233	>	CompletableFutureInc r = new CompletableFutureInc();
3234	>	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3235		f.complete(one);
3236	<	checkIncomplete(g);
1871	<	f2.complete(two);
1872	<	checkCompletedNormally(g, three);
3236	>	checkCompletedNormally(g, two);
3237		}
3238
3239		/**
3240	<	* thenCombineAsync result completes exceptionally after exceptional
3241	<	* completion of source
3240	>	* thenComposeAsync result completes exceptionally after
3241	>	* exceptional completion of source
3242		*/
3243	<	public void testThenCombineAsync2E() {
3244	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3245	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3246	<	CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
3243	>	public void testThenComposeAsync2E() {
3244	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3245	>	CompletableFutureInc r = new CompletableFutureInc();
3246	>	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3247		f.completeExceptionally(new CFException());
1884	–	f2.complete(two);
1885	–	checkCompletedWithWrappedCFException(g);
1886	–
1887	–	f = new CompletableFuture<Integer>();
1888	–	f2 = new CompletableFuture<Integer>();
1889	–	g = f.thenCombineAsync(f2, add, new ThreadExecutor());
1890	–	f.complete(one);
1891	–	f2.completeExceptionally(new CFException());
3248		checkCompletedWithWrappedCFException(g);
3249		}
3250
3251		/**
3252	<	* thenCombineAsync result completes exceptionally if action does
3252	>	* thenComposeAsync result completes exceptionally if action does
3253		*/
3254	<	public void testThenCombineAsync3E() {
3255	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3256	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3257	<	FailingBiFunction r = new FailingBiFunction();
1902	<	CompletableFuture<Integer> g = f.thenCombineAsync(f2, r, new ThreadExecutor());
3254	>	public void testThenComposeAsync3E() {
3255	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3256	>	FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
3257	>	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3258		f.complete(one);
1904	–	checkIncomplete(g);
1905	–	f2.complete(two);
3259		checkCompletedWithWrappedCFException(g);
3260		}
3261
3262		/**
3263	<	* thenCombineAsync result completes exceptionally if either source cancelled
3263	>	* thenComposeAsync result completes exceptionally if source cancelled
3264		*/
3265	<	public void testThenCombineAsync4E() {
3266	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3267	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3268	<	CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
3265	>	public void testThenComposeAsync4E() {
3266	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3267	>	CompletableFutureInc r = new CompletableFutureInc();
3268	>	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3269		assertTrue(f.cancel(true));
1917	–	f2.complete(two);
1918	–	checkCompletedWithWrappedCancellationException(g);
1919	–
1920	–	f = new CompletableFuture<Integer>();
1921	–	f2 = new CompletableFuture<Integer>();
1922	–	g = f.thenCombineAsync(f2, add, new ThreadExecutor());
1923	–	f.complete(one);
1924	–	assertTrue(f2.cancel(true));
3270		checkCompletedWithWrappedCancellationException(g);
3271		}
3272
3273	+	// other static methods
3274	+
3275		/**
3276	<	* thenAcceptBothAsync result completes normally after normal
3277	<	* completion of sources
3276	>	* allOf(no component futures) returns a future completed normally
3277	>	* with the value null
3278		*/
3279	<	public void testThenAcceptBothAsyncE() {
3280	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3281	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1935	<	AddAction r = new AddAction();
1936	<	CompletableFuture<Void> g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor());
1937	<	f.complete(one);
1938	<	checkIncomplete(g);
1939	<	f2.complete(two);
1940	<	checkCompletedNormally(g, null);
1941	<	assertEquals(r.value, 3);
3279	>	public void testAllOf_empty() throws Exception {
3280	>	CompletableFuture<Void> f = CompletableFuture.allOf();
3281	>	checkCompletedNormally(f, null);
3282		}
3283
3284		/**
3285	<	* thenAcceptBothAsync result completes exceptionally after exceptional
3286	<	* completion of source
3285	>	* allOf returns a future completed normally with the value null
3286	>	* when all components complete normally
3287		*/
3288	<	public void testThenAcceptBothAsync2E() {
3289	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3290	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3291	<	AddAction r = new AddAction();
3292	<	CompletableFuture<Void> g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor());
3293	<	f.completeExceptionally(new CFException());
3294	<	f2.complete(two);
3295	<	checkCompletedWithWrappedCFException(g);
3296	<
3297	<	r = new AddAction();
3298	<	f = new CompletableFuture<Integer>();
3299	<	f2 = new CompletableFuture<Integer>();
3300	<	g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor());
3301	<	f.complete(one);
1962	<	f2.completeExceptionally(new CFException());
1963	<	checkCompletedWithWrappedCFException(g);
3288	>	public void testAllOf_normal() throws Exception {
3289	>	for (int k = 1; k < 20; ++k) {
3290	>	CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3291	>	for (int i = 0; i < k; ++i)
3292	>	fs[i] = new CompletableFuture<>();
3293	>	CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3294	>	for (int i = 0; i < k; ++i) {
3295	>	checkIncomplete(f);
3296	>	checkIncomplete(CompletableFuture.allOf(fs));
3297	>	fs[i].complete(one);
3298	>	}
3299	>	checkCompletedNormally(f, null);
3300	>	checkCompletedNormally(CompletableFuture.allOf(fs), null);
3301	>	}
3302		}
3303
3304		/**
3305	<	* thenAcceptBothAsync result completes exceptionally if action does
3305	>	* anyOf(no component futures) returns an incomplete future
3306		*/
3307	<	public void testThenAcceptBothAsync3E() {
3308	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3309	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1972	<	FailingBiConsumer r = new FailingBiConsumer();
1973	<	CompletableFuture<Void> g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor());
1974	<	f.complete(one);
1975	<	checkIncomplete(g);
1976	<	f2.complete(two);
1977	<	checkCompletedWithWrappedCFException(g);
3307	>	public void testAnyOf_empty() throws Exception {
3308	>	CompletableFuture<Object> f = CompletableFuture.anyOf();
3309	>	checkIncomplete(f);
3310		}
3311
3312		/**
3313	<	* thenAcceptBothAsync result completes exceptionally if either source cancelled
3313	>	* anyOf returns a future completed normally with a value when
3314	>	* a component future does
3315		*/
3316	<	public void testThenAcceptBothAsync4E() {
3317	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3318	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3319	<	AddAction r = new AddAction();
3320	<	CompletableFuture<Void> g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor());
3321	<	assertTrue(f.cancel(true));
3322	<	f2.complete(two);
3323	<	checkCompletedWithWrappedCancellationException(g);
3324	<
3325	<	r = new AddAction();
3326	<	f = new CompletableFuture<Integer>();
3327	<	f2 = new CompletableFuture<Integer>();
3328	<	g = f.thenAcceptBothAsync(f2, r, new ThreadExecutor());
1996	<	f.complete(one);
1997	<	assertTrue(f2.cancel(true));
1998	<	checkCompletedWithWrappedCancellationException(g);
3316	>	public void testAnyOf_normal() throws Exception {
3317	>	for (int k = 0; k < 10; ++k) {
3318	>	CompletableFuture[] fs = new CompletableFuture[k];
3319	>	for (int i = 0; i < k; ++i)
3320	>	fs[i] = new CompletableFuture<>();
3321	>	CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3322	>	checkIncomplete(f);
3323	>	for (int i = 0; i < k; ++i) {
3324	>	fs[i].complete(one);
3325	>	checkCompletedNormally(f, one);
3326	>	checkCompletedNormally(CompletableFuture.anyOf(fs), one);
3327	>	}
3328	>	}
3329		}
3330
3331		/**
3332	<	* runAfterBothAsync result completes normally after normal
2003	<	* completion of sources
3332	>	* anyOf result completes exceptionally when any component does.
3333		*/
3334	<	public void testRunAfterBothAsyncE() {
3335	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3336	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3337	<	Noop r = new Noop();
3338	<	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
3339	<	f.complete(one);
3340	<	checkIncomplete(g);
3341	<	f2.complete(two);
3342	<	checkCompletedNormally(g, null);
3343	<	assertTrue(r.ran);
3334	>	public void testAnyOf_exceptional() throws Exception {
3335	>	for (int k = 0; k < 10; ++k) {
3336	>	CompletableFuture[] fs = new CompletableFuture[k];
3337	>	for (int i = 0; i < k; ++i)
3338	>	fs[i] = new CompletableFuture<>();
3339	>	CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3340	>	checkIncomplete(f);
3341	>	for (int i = 0; i < k; ++i) {
3342	>	fs[i].completeExceptionally(new CFException());
3343	>	checkCompletedWithWrappedCFException(f);
3344	>	checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3345	>	}
3346	>	}
3347		}
3348
3349		/**
3350	<	* runAfterBothAsync result completes exceptionally after exceptional
2019	<	* completion of source
3350	>	* Completion methods throw NullPointerException with null arguments
3351		*/
3352	<	public void testRunAfterBothAsync2E() {
3353	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3354	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3355	<	Noop r = new Noop();
3356	<	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
3357	<	f.completeExceptionally(new CFException());
3358	<	f2.complete(two);
3359	<	checkCompletedWithWrappedCFException(g);
3360	<
3361	<	r = new Noop();
3362	<	f = new CompletableFuture<Integer>();
3363	<	f2 = new CompletableFuture<Integer>();
3364	<	g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
3365	<	f.complete(one);
3366	<	f2.completeExceptionally(new CFException());
3367	<	checkCompletedWithWrappedCFException(g);
3352	>	public void testNPE() {
3353	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3354	>	CompletableFuture<Integer> g = new CompletableFuture<>();
3355	>	CompletableFuture<Integer> nullFuture = (CompletableFuture<Integer>)null;
3356	>	CompletableFuture<?> h;
3357	>	ThreadExecutor exec = new ThreadExecutor();
3358	>
3359	>	Runnable[] throwingActions = {
3360	>	() -> CompletableFuture.supplyAsync(null),
3361	>	() -> CompletableFuture.supplyAsync(null, exec),
3362	>	() -> CompletableFuture.supplyAsync(supplyOne, null),
3363	>
3364	>	() -> CompletableFuture.runAsync(null),
3365	>	() -> CompletableFuture.runAsync(null, exec),
3366	>	() -> CompletableFuture.runAsync(() -> {}, null),
3367	>
3368	>	() -> f.completeExceptionally(null),
3369	>
3370	>	() -> f.thenApply(null),
3371	>	() -> f.thenApplyAsync(null),
3372	>	() -> f.thenApplyAsync((x) -> x, null),
3373	>	() -> f.thenApplyAsync(null, exec),
3374	>
3375	>	() -> f.thenAccept(null),
3376	>	() -> f.thenAcceptAsync(null),
3377	>	() -> f.thenAcceptAsync((x) -> {} , null),
3378	>	() -> f.thenAcceptAsync(null, exec),
3379	>
3380	>	() -> f.thenRun(null),
3381	>	() -> f.thenRunAsync(null),
3382	>	() -> f.thenRunAsync(() -> {} , null),
3383	>	() -> f.thenRunAsync(null, exec),
3384	>
3385	>	() -> f.thenCombine(g, null),
3386	>	() -> f.thenCombineAsync(g, null),
3387	>	() -> f.thenCombineAsync(g, null, exec),
3388	>	() -> f.thenCombine(nullFuture, (x, y) -> x),
3389	>	() -> f.thenCombineAsync(nullFuture, (x, y) -> x),
3390	>	() -> f.thenCombineAsync(nullFuture, (x, y) -> x, exec),
3391	>	() -> f.thenCombineAsync(g, (x, y) -> x, null),
3392	>
3393	>	() -> f.thenAcceptBoth(g, null),
3394	>	() -> f.thenAcceptBothAsync(g, null),
3395	>	() -> f.thenAcceptBothAsync(g, null, exec),
3396	>	() -> f.thenAcceptBoth(nullFuture, (x, y) -> {}),
3397	>	() -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}),
3398	>	() -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}, exec),
3399	>	() -> f.thenAcceptBothAsync(g, (x, y) -> {}, null),
3400	>
3401	>	() -> f.runAfterBoth(g, null),
3402	>	() -> f.runAfterBothAsync(g, null),
3403	>	() -> f.runAfterBothAsync(g, null, exec),
3404	>	() -> f.runAfterBoth(nullFuture, () -> {}),
3405	>	() -> f.runAfterBothAsync(nullFuture, () -> {}),
3406	>	() -> f.runAfterBothAsync(nullFuture, () -> {}, exec),
3407	>	() -> f.runAfterBothAsync(g, () -> {}, null),
3408	>
3409	>	() -> f.applyToEither(g, null),
3410	>	() -> f.applyToEitherAsync(g, null),
3411	>	() -> f.applyToEitherAsync(g, null, exec),
3412	>	() -> f.applyToEither(nullFuture, (x) -> x),
3413	>	() -> f.applyToEitherAsync(nullFuture, (x) -> x),
3414	>	() -> f.applyToEitherAsync(nullFuture, (x) -> x, exec),
3415	>	() -> f.applyToEitherAsync(g, (x) -> x, null),
3416	>
3417	>	() -> f.acceptEither(g, null),
3418	>	() -> f.acceptEitherAsync(g, null),
3419	>	() -> f.acceptEitherAsync(g, null, exec),
3420	>	() -> f.acceptEither(nullFuture, (x) -> {}),
3421	>	() -> f.acceptEitherAsync(nullFuture, (x) -> {}),
3422	>	() -> f.acceptEitherAsync(nullFuture, (x) -> {}, exec),
3423	>	() -> f.acceptEitherAsync(g, (x) -> {}, null),
3424	>
3425	>	() -> f.runAfterEither(g, null),
3426	>	() -> f.runAfterEitherAsync(g, null),
3427	>	() -> f.runAfterEitherAsync(g, null, exec),
3428	>	() -> f.runAfterEither(nullFuture, () -> {}),
3429	>	() -> f.runAfterEitherAsync(nullFuture, () -> {}),
3430	>	() -> f.runAfterEitherAsync(nullFuture, () -> {}, exec),
3431	>	() -> f.runAfterEitherAsync(g, () -> {}, null),
3432	>
3433	>	() -> f.thenCompose(null),
3434	>	() -> f.thenComposeAsync(null),
3435	>	() -> f.thenComposeAsync(new CompletableFutureInc(), null),
3436	>	() -> f.thenComposeAsync(null, exec),
3437	>
3438	>	() -> f.exceptionally(null),
3439	>
3440	>	() -> f.handle(null),
3441	>
3442	>	() -> CompletableFuture.allOf((CompletableFuture<?>)null),
3443	>	() -> CompletableFuture.allOf((CompletableFuture<?>[])null),
3444	>	() -> CompletableFuture.allOf(f, null),
3445	>	() -> CompletableFuture.allOf(null, f),
3446	>
3447	>	() -> CompletableFuture.anyOf((CompletableFuture<?>)null),
3448	>	() -> CompletableFuture.anyOf((CompletableFuture<?>[])null),
3449	>	() -> CompletableFuture.anyOf(f, null),
3450	>	() -> CompletableFuture.anyOf(null, f),
3451	>
3452	>	() -> f.obtrudeException(null),
3453	>	};
3454	>
3455	>	assertThrows(NullPointerException.class, throwingActions);
3456	>	assertEquals(0, exec.count.get());
3457	>	}
3458	>
3459	>	/**
3460	>	* toCompletableFuture returns this CompletableFuture.
3461	>	*/
3462	>	public void testToCompletableFuture() {
3463	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3464	>	assertSame(f, f.toCompletableFuture());
3465	>	}
3466	>
3467	>	/**
3468	>	* whenComplete action executes on normal completion, propagating
3469	>	* source result.
3470	>	*/
3471	>	public void testWhenComplete1() {
3472	>	final AtomicInteger a = new AtomicInteger();
3473	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3474	>	CompletableFuture<Integer> g =
3475	>	f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3476	>	f.complete(three);
3477	>	checkCompletedNormally(f, three);
3478	>	checkCompletedNormally(g, three);
3479	>	assertEquals(a.get(), 1);
3480		}
3481
3482		/**
3483	<	* runAfterBothAsync result completes exceptionally if action does
3483	>	* whenComplete action executes on exceptional completion, propagating
3484	>	* source result.
3485		*/
3486	<	public void testRunAfterBothAsync3E() {
3487	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3488	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3489	<	FailingNoop r = new FailingNoop();
3490	<	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
3491	<	f.complete(one);
3492	<	checkIncomplete(g);
3493	<	f2.complete(two);
3494	<	checkCompletedWithWrappedCFException(g);
3486	>	public void testWhenComplete2() {
3487	>	final AtomicInteger a = new AtomicInteger();
3488	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3489	>	CompletableFuture<Integer> g =
3490	>	f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3491	>	f.completeExceptionally(new CFException());
3492	>	assertTrue(f.isCompletedExceptionally());
3493	>	assertTrue(g.isCompletedExceptionally());
3494	>	assertEquals(a.get(), 1);
3495		}
3496
3497		/**
3498	<	* runAfterBothAsync result completes exceptionally if either source cancelled
3498	>	* If a whenComplete action throws an exception when triggered by
3499	>	* a normal completion, it completes exceptionally
3500		*/
3501	<	public void testRunAfterBothAsync4E() {
3502	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3503	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3504	<	Noop r = new Noop();
3505	<	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
3506	<	assertTrue(f.cancel(true));
3507	<	f2.complete(two);
3508	<	checkCompletedWithWrappedCancellationException(g);
3509	<
2065	<	r = new Noop();
2066	<	f = new CompletableFuture<Integer>();
2067	<	f2 = new CompletableFuture<Integer>();
2068	<	g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2069	<	f.complete(one);
2070	<	assertTrue(f2.cancel(true));
2071	<	checkCompletedWithWrappedCancellationException(g);
3501	>	public void testWhenComplete3() {
3502	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3503	>	CompletableFuture<Integer> g =
3504	>	f.whenComplete((Integer x, Throwable t) ->
3505	>	{ throw new CFException(); } );
3506	>	f.complete(three);
3507	>	checkCompletedNormally(f, three);
3508	>	assertTrue(g.isCompletedExceptionally());
3509	>	checkCompletedWithWrappedCFException(g);
3510		}
3511
3512		/**
3513	<	* applyToEitherAsync result completes normally after normal
3514	<	* completion of sources
3513	>	* whenCompleteAsync action executes on normal completion, propagating
3514	>	* source result.
3515		*/
3516	<	public void testApplyToEitherAsyncE() {
3517	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3518	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3519	<	CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
3520	<	f.complete(one);
3521	<	checkCompletedNormally(g, two);
3522	<
3523	<	f = new CompletableFuture<Integer>();
3524	<	f.complete(one);
2087	<	f2 = new CompletableFuture<Integer>();
2088	<	g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2089	<	checkCompletedNormally(g, two);
3516	>	public void testWhenCompleteAsync1() {
3517	>	final AtomicInteger a = new AtomicInteger();
3518	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3519	>	CompletableFuture<Integer> g =
3520	>	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3521	>	f.complete(three);
3522	>	checkCompletedNormally(f, three);
3523	>	checkCompletedNormally(g, three);
3524	>	assertEquals(a.get(), 1);
3525		}
3526
3527		/**
3528	<	* applyToEitherAsync result completes exceptionally after exceptional
3529	<	* completion of source
3528	>	* whenCompleteAsync action executes on exceptional completion, propagating
3529	>	* source result.
3530		*/
3531	<	public void testApplyToEitherAsync2E() {
3532	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3533	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3534	<	CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
3531	>	public void testWhenCompleteAsync2() {
3532	>	final AtomicInteger a = new AtomicInteger();
3533	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3534	>	CompletableFuture<Integer> g =
3535	>	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3536		f.completeExceptionally(new CFException());
3537	<	checkCompletedWithWrappedCFException(g);
2102	<
2103	<	f = new CompletableFuture<Integer>();
2104	<	f2 = new CompletableFuture<Integer>();
2105	<	f2.completeExceptionally(new CFException());
2106	<	g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2107	<	f.complete(one);
3537	>	checkCompletedWithWrappedCFException(f);
3538		checkCompletedWithWrappedCFException(g);
3539		}
3540
3541		/**
3542	<	* applyToEitherAsync result completes exceptionally if action does
3542	>	* If a whenCompleteAsync action throws an exception when
3543	>	* triggered by a normal completion, it completes exceptionally
3544		*/
3545	<	public void testApplyToEitherAsync3E() {
3546	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3547	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3548	<	FailingFunction r = new FailingFunction();
3549	<	CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r, new ThreadExecutor());
3550	<	f.complete(one);
3545	>	public void testWhenCompleteAsync3() {
3546	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3547	>	CompletableFuture<Integer> g =
3548	>	f.whenCompleteAsync((Integer x, Throwable t) ->
3549	>	{ throw new CFException(); } );
3550	>	f.complete(three);
3551	>	checkCompletedNormally(f, three);
3552		checkCompletedWithWrappedCFException(g);
3553		}
3554
3555		/**
3556	<	* applyToEitherAsync result completes exceptionally if either source cancelled
3557	<	*/
2126	<	public void testApplyToEitherAsync4E() {
2127	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2128	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2129	<	CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2130	<	assertTrue(f.cancel(true));
2131	<	checkCompletedWithWrappedCancellationException(g);
2132	<
2133	<	f = new CompletableFuture<Integer>();
2134	<	f2 = new CompletableFuture<Integer>();
2135	<	assertTrue(f2.cancel(true));
2136	<	g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
2137	<	checkCompletedWithWrappedCancellationException(g);
2138	<	}
2139	<
2140	<	/**
2141	<	* acceptEitherAsync result completes normally after normal
2142	<	* completion of sources
3556	>	* whenCompleteAsync action executes on normal completion, propagating
3557	>	* source result.
3558		*/
3559	<	public void testAcceptEitherAsyncE() {
3560	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3561	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3562	<	IncAction r = new IncAction();
3563	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
3564	<	f.complete(one);
3565	<	checkCompletedNormally(g, null);
3566	<	assertEquals(r.value, 2);
3567	<
3568	<	r = new IncAction();
3569	<	f = new CompletableFuture<Integer>();
2155	<	f.complete(one);
2156	<	f2 = new CompletableFuture<Integer>();
2157	<	g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2158	<	checkCompletedNormally(g, null);
2159	<	assertEquals(r.value, 2);
3559	>	public void testWhenCompleteAsync1e() {
3560	>	final AtomicInteger a = new AtomicInteger();
3561	>	ThreadExecutor exec = new ThreadExecutor();
3562	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3563	>	CompletableFuture<Integer> g =
3564	>	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3565	>	exec);
3566	>	f.complete(three);
3567	>	checkCompletedNormally(f, three);
3568	>	checkCompletedNormally(g, three);
3569	>	assertEquals(a.get(), 1);
3570		}
3571
3572		/**
3573	<	* acceptEitherAsync result completes exceptionally after exceptional
3574	<	* completion of source
3573	>	* whenCompleteAsync action executes on exceptional completion, propagating
3574	>	* source result.
3575		*/
3576	<	public void testAcceptEitherAsync2E() {
3577	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3578	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3579	<	IncAction r = new IncAction();
3580	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
3576	>	public void testWhenCompleteAsync2e() {
3577	>	final AtomicInteger a = new AtomicInteger();
3578	>	ThreadExecutor exec = new ThreadExecutor();
3579	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3580	>	CompletableFuture<Integer> g =
3581	>	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3582	>	exec);
3583		f.completeExceptionally(new CFException());
3584	<	checkCompletedWithWrappedCFException(g);
2173	<
2174	<	r = new IncAction();
2175	<	f = new CompletableFuture<Integer>();
2176	<	f2 = new CompletableFuture<Integer>();
2177	<	f2.completeExceptionally(new CFException());
2178	<	g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2179	<	f.complete(one);
3584	>	checkCompletedWithWrappedCFException(f);
3585		checkCompletedWithWrappedCFException(g);
3586		}
3587
3588		/**
3589	<	* acceptEitherAsync result completes exceptionally if action does
3589	>	* If a whenCompleteAsync action throws an exception when triggered
3590	>	* by a normal completion, it completes exceptionally
3591		*/
3592	<	public void testAcceptEitherAsync3E() {
3593	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3594	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3595	<	FailingConsumer r = new FailingConsumer();
3596	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
3597	<	f.complete(one);
3592	>	public void testWhenCompleteAsync3e() {
3593	>	ThreadExecutor exec = new ThreadExecutor();
3594	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3595	>	CompletableFuture<Integer> g =
3596	>	f.whenCompleteAsync((Integer x, Throwable t) ->
3597	>	{ throw new CFException(); },
3598	>	exec);
3599	>	f.complete(three);
3600	>	checkCompletedNormally(f, three);
3601		checkCompletedWithWrappedCFException(g);
3602		}
3603
3604		/**
3605	<	* acceptEitherAsync result completes exceptionally if either
3606	<	* source cancelled
3605	>	* handleAsync action completes normally with function value on
3606	>	* either normal or exceptional completion of source
3607		*/
3608	<	public void testAcceptEitherAsync4E() {
3609	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3610	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3611	<	IncAction r = new IncAction();
3612	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
3613	<	assertTrue(f.cancel(true));
3614	<	checkCompletedWithWrappedCancellationException(g);
3608	>	public void testHandleAsync() {
3609	>	CompletableFuture<Integer> f, g;
3610	>	IntegerHandler r;
3611	>
3612	>	f = new CompletableFuture<>();
3613	>	g = f.handleAsync(r = new IntegerHandler());
3614	>	assertFalse(r.ran);
3615	>	f.completeExceptionally(new CFException());
3616	>	checkCompletedWithWrappedCFException(f);
3617	>	checkCompletedNormally(g, three);
3618	>	assertTrue(r.ran);
3619
3620	<	r = new IncAction();
3621	<	f = new CompletableFuture<Integer>();
3622	<	f2 = new CompletableFuture<Integer>();
3623	<	assertTrue(f2.cancel(true));
3624	<	g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
3625	<	checkCompletedWithWrappedCancellationException(g);
3626	<	}
3620	>	f = new CompletableFuture<>();
3621	>	g = f.handleAsync(r = new IntegerHandler());
3622	>	assertFalse(r.ran);
3623	>	f.completeExceptionally(new CFException());
3624	>	checkCompletedWithWrappedCFException(f);
3625	>	checkCompletedNormally(g, three);
3626	>	assertTrue(r.ran);
3627
3628	<	/**
3629	<	* runAfterEitherAsync result completes normally after normal
3630	<	* completion of sources
2218	<	*/
2219	<	public void testRunAfterEitherAsyncE() {
2220	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2221	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2222	<	Noop r = new Noop();
2223	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3628	>	f = new CompletableFuture<>();
3629	>	g = f.handleAsync(r = new IntegerHandler());
3630	>	assertFalse(r.ran);
3631		f.complete(one);
3632	<	checkCompletedNormally(g, null);
3632	>	checkCompletedNormally(f, one);
3633	>	checkCompletedNormally(g, two);
3634		assertTrue(r.ran);
3635
3636	<	r = new Noop();
3637	<	f = new CompletableFuture<Integer>();
3636	>	f = new CompletableFuture<>();
3637	>	g = f.handleAsync(r = new IntegerHandler());
3638	>	assertFalse(r.ran);
3639		f.complete(one);
3640	<	f2 = new CompletableFuture<Integer>();
3641	<	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2233	<	checkCompletedNormally(g, null);
3640	>	checkCompletedNormally(f, one);
3641	>	checkCompletedNormally(g, two);
3642		assertTrue(r.ran);
3643		}
3644
3645		/**
3646	<	* runAfterEitherAsync result completes exceptionally after exceptional
3647	<	* completion of source
3648	<	*/
3649	<	public void testRunAfterEitherAsync2E() {
3650	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
3651	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
3652	<	Noop r = new Noop();
3653	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3646	>	* handleAsync action with Executor completes normally with
3647	>	* function value on either normal or exceptional completion of
3648	>	* source
3649	>	*/
3650	>	public void testHandleAsync2() {
3651	>	CompletableFuture<Integer> f, g;
3652	>	ThreadExecutor exec = new ThreadExecutor();
3653	>	IntegerHandler r;
3654	>
3655	>	f = new CompletableFuture<>();
3656	>	g = f.handleAsync(r = new IntegerHandler(), exec);
3657	>	assertFalse(r.ran);
3658		f.completeExceptionally(new CFException());
3659	<	checkCompletedWithWrappedCFException(g);
3660	<
3661	<	r = new Noop();
2250	<	f = new CompletableFuture<Integer>();
2251	<	f2 = new CompletableFuture<Integer>();
2252	<	f2.completeExceptionally(new CFException());
2253	<	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2254	<	f.complete(one);
2255	<	checkCompletedWithWrappedCFException(g);
2256	<	}
2257	<
2258	<	/**
2259	<	* runAfterEitherAsync result completes exceptionally if action does
2260	<	*/
2261	<	public void testRunAfterEitherAsync3E() {
2262	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2263	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2264	<	FailingNoop r = new FailingNoop();
2265	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2266	<	f.complete(one);
2267	<	checkCompletedWithWrappedCFException(g);
2268	<	}
2269	<
2270	<	/**
2271	<	* runAfterEitherAsync result completes exceptionally if either
2272	<	* source cancelled
2273	<	*/
2274	<	public void testRunAfterEitherAsync4E() {
2275	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2276	<	CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2277	<	Noop r = new Noop();
2278	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2279	<	assertTrue(f.cancel(true));
2280	<	checkCompletedWithWrappedCancellationException(g);
3659	>	checkCompletedWithWrappedCFException(f);
3660	>	checkCompletedNormally(g, three);
3661	>	assertTrue(r.ran);
3662
3663	<	r = new Noop();
3664	<	f = new CompletableFuture<Integer>();
3665	<	f2 = new CompletableFuture<Integer>();
3666	<	assertTrue(f2.cancel(true));
3667	<	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3668	<	checkCompletedWithWrappedCancellationException(g);
3669	<	}
3663	>	f = new CompletableFuture<>();
3664	>	g = f.handleAsync(r = new IntegerHandler(), exec);
3665	>	assertFalse(r.ran);
3666	>	f.completeExceptionally(new CFException());
3667	>	checkCompletedWithWrappedCFException(f);
3668	>	checkCompletedNormally(g, three);
3669	>	assertTrue(r.ran);
3670
3671	<	/**
3672	<	* thenComposeAsync result completes normally after normal
3673	<	* completion of source
2293	<	*/
2294	<	public void testThenComposeAsyncE() {
2295	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2296	<	CompletableFutureInc r = new CompletableFutureInc();
2297	<	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3671	>	f = new CompletableFuture<>();
3672	>	g = f.handleAsync(r = new IntegerHandler(), exec);
3673	>	assertFalse(r.ran);
3674		f.complete(one);
3675	+	checkCompletedNormally(f, one);
3676		checkCompletedNormally(g, two);
3677	<	}
2301	<
2302	<	/**
2303	<	* thenComposeAsync result completes exceptionally after
2304	<	* exceptional completion of source
2305	<	*/
2306	<	public void testThenComposeAsync2E() {
2307	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2308	<	CompletableFutureInc r = new CompletableFutureInc();
2309	<	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2310	<	f.completeExceptionally(new CFException());
2311	<	checkCompletedWithWrappedCFException(g);
2312	<	}
3677	>	assertTrue(r.ran);
3678
3679	<	/**
3680	<	* thenComposeAsync result completes exceptionally if action does
3681	<	*/
2317	<	public void testThenComposeAsync3E() {
2318	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2319	<	FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
2320	<	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3679	>	f = new CompletableFuture<>();
3680	>	g = f.handleAsync(r = new IntegerHandler(), exec);
3681	>	assertFalse(r.ran);
3682		f.complete(one);
3683	<	checkCompletedWithWrappedCFException(g);
3684	<	}
3685	<
2325	<	/**
2326	<	* thenComposeAsync result completes exceptionally if source cancelled
2327	<	*/
2328	<	public void testThenComposeAsync4E() {
2329	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2330	<	CompletableFutureInc r = new CompletableFutureInc();
2331	<	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
2332	<	assertTrue(f.cancel(true));
2333	<	checkCompletedWithWrappedCancellationException(g);
2334	<	}
2335	<
2336	<	// other static methods
2337	<
2338	<	/**
2339	<	* allOf(no component futures) returns a future completed normally
2340	<	* with the value null
2341	<	*/
2342	<	public void testAllOf_empty() throws Exception {
2343	<	CompletableFuture<?> f = CompletableFuture.allOf();
2344	<	checkCompletedNormally(f, null);
2345	<	}
2346	<
2347	<	/**
2348	<	* allOf returns a future completed when all components complete
2349	<	*/
2350	<	public void testAllOf() throws Exception {
2351	<	for (int k = 1; k < 20; ++k) {
2352	<	CompletableFuture[] fs = new CompletableFuture[k];
2353	<	for (int i = 0; i < k; ++i)
2354	<	fs[i] = new CompletableFuture<Integer>();
2355	<	CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2356	<	for (int i = 0; i < k; ++i) {
2357	<	checkIncomplete(f);
2358	<	fs[i].complete(one);
2359	<	}
2360	<	checkCompletedNormally(f, null);
2361	<	}
2362	<	}
2363	<
2364	<	/**
2365	<	* anyOf(no component futures) returns an incomplete future
2366	<	*/
2367	<	public void testAnyOf_empty() throws Exception {
2368	<	CompletableFuture<?> f = CompletableFuture.anyOf();
2369	<	checkIncomplete(f);
2370	<	}
2371	<
2372	<	/**
2373	<	* allOf returns a future completed when any components complete
2374	<	*/
2375	<	public void testAnyOf() throws Exception {
2376	<	for (int k = 1; k < 20; ++k) {
2377	<	CompletableFuture[] fs = new CompletableFuture[k];
2378	<	for (int i = 0; i < k; ++i)
2379	<	fs[i] = new CompletableFuture<Integer>();
2380	<	CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
2381	<	checkIncomplete(f);
2382	<	for (int i = 0; i < k; ++i) {
2383	<	fs[i].complete(one);
2384	<	checkCompletedNormally(f, one);
2385	<	}
2386	<	}
2387	<	}
2388	<
2389	<	/**
2390	<	* Completion methods throw NullPointerException with null arguments
2391	<	*/
2392	<	public void testNPE() {
2393	<	CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2394	<	CompletableFuture<Integer> g = new CompletableFuture<Integer>();
2395	<	CompletableFuture h;
2396	<	Runnable[] actions = {
2397	<	() => f.thenApply(null),
2398	<	}
2399	<	try { h = f.thenApply(null); } catch (NullPointerException ok) {}
2400	<	try { h = f.thenAccept(null); } catch (NullPointerException ok) {}
2401	<	try { h = f.thenRun(null); } catch (NullPointerException ok) {}
2402	<	try { h = f.thenCombine(g, null); } catch (NullPointerException ok) {}
2403	<	try { h = f.thenCombine(null, null); } catch (NullPointerException ok) {}
2404	<	try { h = f.applyToEither(g, null); } catch (NullPointerException ok) {}
2405	<	try { h = f.applyToEither(null, null); } catch (NullPointerException ok) {}
2406	<	try { h = f.thenAcceptBoth(g, null); } catch (NullPointerException ok) {}
2407	<	try { h = f.thenAcceptBoth(null, null); } catch (NullPointerException ok) {}
2408	<	try { h = f.runAfterEither(g, null); } catch (NullPointerException ok) {}
2409	<	try { h = f.runAfterEither(null, null); } catch (NullPointerException ok) {}
2410	<	try { h = f.runAfterBoth(g, null); } catch (NullPointerException ok) {}
2411	<	try { h = f.runAfterBoth(null, null); } catch (NullPointerException ok) {}
2412	<	try { h = f.exceptionally(null); } catch (NullPointerException ok) {}
2413	<	try { h = f.handle(null); } catch (NullPointerException ok) {}
2414	<	try { h = f.thenCompose(null); } catch (NullPointerException ok) {}
2415	<
2416	<	try { h = f.thenApplyAsync(null); } catch (NullPointerException ok) {}
2417	<	try { h = f.thenAcceptAsync(null); } catch (NullPointerException ok) {}
2418	<	try { h = f.thenRunAsync(null); } catch (NullPointerException ok) {}
2419	<	try { h = f.thenCombineAsync(g, null); } catch (NullPointerException ok) {}
2420	<	try { h = f.thenCombineAsync(null, null); } catch (NullPointerException ok) {}
2421	<	try { h = f.applyToEitherAsync(g, null); } catch (NullPointerException ok) {}
2422	<	try { h = f.applyToEitherAsync(null, null); } catch (NullPointerException ok) {}
2423	<	try { h = f.thenAcceptBothAsync(g, null); } catch (NullPointerException ok) {}
2424	<	try { h = f.thenAcceptBothAsync(null, null); } catch (NullPointerException ok) {}
2425	<	try { h = f.runAfterEitherAsync(g, null); } catch (NullPointerException ok) {}
2426	<	try { h = f.runAfterEitherAsync(null, null); } catch (NullPointerException ok) {}
2427	<	try { h = f.runAfterBothAsync(g, null); } catch (NullPointerException ok) {}
2428	<	try { h = f.runAfterBothAsync(null, null); } catch (NullPointerException ok) {}
2429	<
3683	>	checkCompletedNormally(f, one);
3684	>	checkCompletedNormally(g, two);
3685	>	assertTrue(r.ran);
3686		}
3687
2432	–
3688		}

Diff Legend

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