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.33 by jsr166, Sun Jun 1 20:40:13 2014 UTC vs.
Revision 1.36 by jsr166, Sun Jun 1 23:12:45 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 317 | Line 318 | public class CompletableFutureTest exten
318
319		// Choose non-commutative actions for better coverage
320
321	+	// A non-commutative function that handles null values as well
322	+	public static int subtract(Integer x, Integer y) {
323	+	return ((x == null) ? 42 : x.intValue())
324	+	- ((y == null) ? 99 : y.intValue());
325	+	}
326	+
327		static final Supplier<Integer> supplyOne =
328		() -> Integer.valueOf(1);
329		static final Function<Integer, Integer> inc =
330		(Integer x) -> Integer.valueOf(x.intValue() + 1);
331		static final BiFunction<Integer, Integer, Integer> subtract =
332	<	(Integer x, Integer y) -> Integer.valueOf(x.intValue() - y.intValue());
332	>	(Integer x, Integer y) -> subtract(x, y);
333		static final class IncAction implements Consumer<Integer> {
334		int value;
335		public void accept(Integer x) { value = x.intValue() + 1; }
336		}
337		static final class SubtractAction implements BiConsumer<Integer, Integer> {
338	+	volatile int invocationCount = 0;
339		int value;
340	+	// Check this action was invoked exactly once when result is computed.
341	+	public boolean ran() { return invocationCount == 1; }
342		public void accept(Integer x, Integer y) {
343	<	value = x.intValue() - y.intValue();
343	>	invocationCount++;
344	>	value = subtract(x, y);
345	>	}
346	>	}
347	>	static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
348	>	volatile int invocationCount = 0;
349	>	int value;
350	>	// Check this action was invoked exactly once when result is computed.
351	>	public boolean ran() { return invocationCount == 1; }
352	>	public Integer apply(Integer x, Integer y) {
353	>	invocationCount++;
354	>	return subtract(x, y);
355		}
356		}
357		static final class Noop implements Runnable {
#	Line 405 | Line 426 | public class CompletableFutureTest exten
426		}
427
428		/**
429	+	* Permits the testing of parallel code for the 3 different
430	+	* execution modes without repeating all the testing code.
431	+	*/
432	+	enum ExecutionMode {
433	+	DEFAULT {
434	+	public <T,U> CompletableFuture<Void> runAfterBoth
435	+	(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
436	+	return f.runAfterBoth(g, a);
437	+	}
438	+	public <T,U> CompletableFuture<Void> thenAcceptBoth
439	+	(CompletableFuture<T> f,
440	+	CompletionStage<? extends U> g,
441	+	BiConsumer<? super T,? super U> a) {
442	+	return f.thenAcceptBoth(g, a);
443	+	}
444	+	public <T,U,V> CompletableFuture<V> thenCombine
445	+	(CompletableFuture<T> f,
446	+	CompletionStage<? extends U> g,
447	+	BiFunction<? super T,? super U,? extends V> a) {
448	+	return f.thenCombine(g, a);
449	+	}
450	+	},
451	+
452	+	//             /** Experimental way to do more testing */
453	+	//         REVERSE_DEFAULT {
454	+	//             public <T,U> CompletableFuture<Void> runAfterBoth
455	+	//                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
456	+	//                 return g.runAfterBoth(f, a);
457	+	//             }
458	+	//             public <T,U> CompletableFuture<Void> thenAcceptBoth
459	+	//                 (CompletableFuture<T> f,
460	+	//                  CompletionStage<? extends U> g,
461	+	//                  BiConsumer<? super T,? super U> a) {
462	+	//                 return DEFAULT.thenAcceptBoth(f, g, a);
463	+	//             }
464	+	//         },
465	+
466	+	DEFAULT_ASYNC {
467	+	public <T,U> CompletableFuture<Void> runAfterBoth
468	+	(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
469	+	return f.runAfterBothAsync(g, a);
470	+	}
471	+	public <T,U> CompletableFuture<Void> thenAcceptBoth
472	+	(CompletableFuture<T> f,
473	+	CompletionStage<? extends U> g,
474	+	BiConsumer<? super T,? super U> a) {
475	+	return f.thenAcceptBothAsync(g, a);
476	+	}
477	+	public <T,U,V> CompletableFuture<V> thenCombine
478	+	(CompletableFuture<T> f,
479	+	CompletionStage<? extends U> g,
480	+	BiFunction<? super T,? super U,? extends V> a) {
481	+	return f.thenCombineAsync(g, a);
482	+	}
483	+	},
484	+
485	+	//         REVERSE_DEFAULT_ASYNC {
486	+	//             public <T,U> CompletableFuture<Void> runAfterBoth
487	+	//                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
488	+	//                 return f.runAfterBothAsync(g, a);
489	+	//             }
490	+	//             public <T,U> CompletableFuture<Void> thenAcceptBoth
491	+	//                 (CompletableFuture<T> f,
492	+	//                  CompletionStage<? extends U> g,
493	+	//                  BiConsumer<? super T,? super U> a) {
494	+	//                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
495	+	//             }
496	+	//         },
497	+
498	+	EXECUTOR {
499	+	public <T,U> CompletableFuture<Void> runAfterBoth
500	+	(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
501	+	return f.runAfterBothAsync(g, a, new ThreadExecutor());
502	+	}
503	+	public <T,U> CompletableFuture<Void> thenAcceptBoth
504	+	(CompletableFuture<T> f,
505	+	CompletionStage<? extends U> g,
506	+	BiConsumer<? super T,? super U> a) {
507	+	return f.thenAcceptBothAsync(g, a, new ThreadExecutor());
508	+	}
509	+	public <T,U,V> CompletableFuture<V> thenCombine
510	+	(CompletableFuture<T> f,
511	+	CompletionStage<? extends U> g,
512	+	BiFunction<? super T,? super U,? extends V> a) {
513	+	return f.thenCombineAsync(g, a, new ThreadExecutor());
514	+	}
515	+	};
516	+
517	+	public abstract <T,U> CompletableFuture<Void> runAfterBoth
518	+	(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
519	+	public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
520	+	(CompletableFuture<T> f,
521	+	CompletionStage<? extends U> g,
522	+	BiConsumer<? super T,? super U> a);
523	+	public abstract <T,U,V> CompletableFuture<V> thenCombine
524	+	(CompletableFuture<T> f,
525	+	CompletionStage<? extends U> g,
526	+	BiFunction<? super T,? super U,? extends V> a);
527	+	}
528	+
529	+	/**
530		* exceptionally action completes with function value on source
531		* exception; otherwise with source value
532		*/
#	Line 696 | Line 818 | public class CompletableFutureTest exten
818		* thenCombine result completes normally after normal completion
819		* of sources
820		*/
821	<	public void testThenCombine() {
822	<	CompletableFuture<Integer> f, g, h;
821	>	public void testThenCombine_normalCompletion1() {
822	>	for (ExecutionMode m : ExecutionMode.values())
823	>	for (Integer v1 : new Integer[] { 1, null })
824	>	for (Integer v2 : new Integer[] { 2, null }) {
825
826	<	f = new CompletableFuture<>();
827	<	g = new CompletableFuture<>();
828	<	h = f.thenCombine(g, subtract);
829	<	f.complete(3);
826	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
827	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
828	>	final SubtractFunction r = new SubtractFunction();
829	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
830	>
831	>	f.complete(v1);
832		checkIncomplete(h);
833	<	g.complete(1);
834	<	checkCompletedNormally(h, 2);
833	>	assertFalse(r.ran());
834	>	g.complete(v2);
835
836	<	f = new CompletableFuture<>();
837	<	g = new CompletableFuture<>();
838	<	h = f.thenCombine(g, subtract);
839	<	g.complete(1);
836	>	checkCompletedNormally(h, subtract(v1, v2));
837	>	checkCompletedNormally(f, v1);
838	>	checkCompletedNormally(g, v2);
839	>	}
840	>	}
841	>
842	>	public void testThenCombine_normalCompletion2() {
843	>	for (ExecutionMode m : ExecutionMode.values())
844	>	for (Integer v1 : new Integer[] { 1, null })
845	>	for (Integer v2 : new Integer[] { 2, null }) {
846	>
847	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
848	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
849	>	final SubtractFunction r = new SubtractFunction();
850	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
851	>
852	>	g.complete(v2);
853		checkIncomplete(h);
854	<	f.complete(3);
855	<	checkCompletedNormally(h, 2);
854	>	assertFalse(r.ran());
855	>	f.complete(v1);
856
857	<	f = new CompletableFuture<>();
858	<	g = new CompletableFuture<>();
859	<	g.complete(1);
860	<	f.complete(3);
861	<	h = f.thenCombine(g, subtract);
862	<	checkCompletedNormally(h, 2);
857	>	checkCompletedNormally(h, subtract(v1, v2));
858	>	checkCompletedNormally(f, v1);
859	>	checkCompletedNormally(g, v2);
860	>	}
861	>	}
862	>
863	>	public void testThenCombine_normalCompletion3() {
864	>	for (ExecutionMode m : ExecutionMode.values())
865	>	for (Integer v1 : new Integer[] { 1, null })
866	>	for (Integer v2 : new Integer[] { 2, null }) {
867	>
868	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
869	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
870	>	final SubtractFunction r = new SubtractFunction();
871	>
872	>	g.complete(v2);
873	>	f.complete(v1);
874	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
875	>
876	>	checkCompletedNormally(h, subtract(v1, v2));
877	>	checkCompletedNormally(f, v1);
878	>	checkCompletedNormally(g, v2);
879	>	}
880	>	}
881	>
882	>	public void testThenCombine_normalCompletion4() {
883	>	for (ExecutionMode m : ExecutionMode.values())
884	>	for (Integer v1 : new Integer[] { 1, null })
885	>	for (Integer v2 : new Integer[] { 2, null }) {
886	>
887	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
888	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
889	>	final SubtractFunction r = new SubtractFunction();
890	>
891	>	f.complete(v1);
892	>	g.complete(v2);
893	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
894	>
895	>	checkCompletedNormally(h, subtract(v1, v2));
896	>	checkCompletedNormally(f, v1);
897	>	checkCompletedNormally(g, v2);
898	>	}
899		}
900
901		/**
902		* thenCombine result completes exceptionally after exceptional
903		* completion of either source
904		*/
905	<	public void testThenCombine2() {
906	<	CompletableFuture<Integer> f, g, h;
905	>	public void testThenCombine_exceptionalCompletion1() {
906	>	for (ExecutionMode m : ExecutionMode.values())
907	>	for (Integer v1 : new Integer[] { 1, null }) {
908
909	<	f = new CompletableFuture<>();
910	<	g = new CompletableFuture<>();
911	<	h = f.thenCombine(g, subtract);
912	<	f.completeExceptionally(new CFException());
909	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
910	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
911	>	final SubtractFunction r = new SubtractFunction();
912	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
913	>	final CFException ex = new CFException();
914	>
915	>	f.completeExceptionally(ex);
916		checkIncomplete(h);
917	<	g.complete(1);
739	<	checkCompletedWithWrappedCFException(h);
917	>	g.complete(v1);
918
919	<	f = new CompletableFuture<>();
920	<	g = new CompletableFuture<>();
921	<	h = f.thenCombine(g, subtract);
922	<	g.completeExceptionally(new CFException());
919	>	checkCompletedWithWrappedCFException(h, ex);
920	>	checkCompletedWithWrappedCFException(f, ex);
921	>	assertFalse(r.ran());
922	>	checkCompletedNormally(g, v1);
923	>	}
924	>	}
925	>
926	>	public void testThenCombine_exceptionalCompletion2() {
927	>	for (ExecutionMode m : ExecutionMode.values())
928	>	for (Integer v1 : new Integer[] { 1, null }) {
929	>
930	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
931	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
932	>	final SubtractFunction r = new SubtractFunction();
933	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, subtract);
934	>	final CFException ex = new CFException();
935	>
936	>	g.completeExceptionally(ex);
937		checkIncomplete(h);
938	<	f.complete(3);
747	<	checkCompletedWithWrappedCFException(h);
938	>	f.complete(v1);
939
940	<	f = new CompletableFuture<>();
941	<	g = new CompletableFuture<>();
942	<	f.complete(3);
943	<	g.completeExceptionally(new CFException());
944	<	h = f.thenCombine(g, subtract);
945	<	checkCompletedWithWrappedCFException(h);
940	>	checkCompletedWithWrappedCFException(h, ex);
941	>	checkCompletedWithWrappedCFException(g, ex);
942	>	assertFalse(r.ran());
943	>	checkCompletedNormally(f, v1);
944	>	}
945	>	}
946
947	<	f = new CompletableFuture<>();
948	<	g = new CompletableFuture<>();
949	<	f.completeExceptionally(new CFException());
950	<	g.complete(3);
951	<	h = f.thenCombine(g, subtract);
952	<	checkCompletedWithWrappedCFException(h);
947	>	public void testThenCombine_exceptionalCompletion3() {
948	>	for (ExecutionMode m : ExecutionMode.values())
949	>	for (Integer v1 : new Integer[] { 1, null }) {
950	>
951	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
952	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
953	>	final SubtractFunction r = new SubtractFunction();
954	>	final CFException ex = new CFException();
955	>
956	>	g.completeExceptionally(ex);
957	>	f.complete(v1);
958	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
959	>
960	>	checkCompletedWithWrappedCFException(h, ex);
961	>	checkCompletedWithWrappedCFException(g, ex);
962	>	assertFalse(r.ran());
963	>	checkCompletedNormally(f, v1);
964	>	}
965	>	}
966	>
967	>	public void testThenCombine_exceptionalCompletion4() {
968	>	for (ExecutionMode m : ExecutionMode.values())
969	>	for (Integer v1 : new Integer[] { 1, null }) {
970	>
971	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
972	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
973	>	final SubtractFunction r = new SubtractFunction();
974	>	final CFException ex = new CFException();
975	>
976	>	f.completeExceptionally(ex);
977	>	g.complete(v1);
978	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, subtract);
979	>
980	>	checkCompletedWithWrappedCFException(h, ex);
981	>	checkCompletedWithWrappedCFException(f, ex);
982	>	assertFalse(r.ran());
983	>	checkCompletedNormally(g, v1);
984	>	}
985		}
986
987		/**
988		* thenCombine result completes exceptionally if action does
989		*/
990	<	public void testThenCombine3() {
991	<	CompletableFuture<Integer> f = new CompletableFuture<>();
992	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
993	<	FailingBiFunction r = new FailingBiFunction();
994	<	CompletableFuture<Integer> g = f.thenCombine(f2, r);
995	<	f.complete(one);
996	<	checkIncomplete(g);
997	<	assertFalse(r.ran);
998	<	f2.complete(two);
999	<	checkCompletedWithWrappedCFException(g);
1000	<	assertTrue(r.ran);
990	>	public void testThenCombine_actionFailed1() {
991	>	for (ExecutionMode m : ExecutionMode.values())
992	>	for (Integer v1 : new Integer[] { 1, null })
993	>	for (Integer v2 : new Integer[] { 2, null }) {
994	>
995	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
996	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
997	>	final FailingBiFunction r = new FailingBiFunction();
998	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
999	>
1000	>	f.complete(v1);
1001	>	checkIncomplete(h);
1002	>	g.complete(v2);
1003	>
1004	>	checkCompletedWithWrappedCFException(h);
1005	>	checkCompletedNormally(f, v1);
1006	>	checkCompletedNormally(g, v2);
1007	>	}
1008	>	}
1009	>
1010	>	public void testThenCombine_actionFailed2() {
1011	>	for (ExecutionMode m : ExecutionMode.values())
1012	>	for (Integer v1 : new Integer[] { 1, null })
1013	>	for (Integer v2 : new Integer[] { 2, null }) {
1014	>
1015	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1016	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1017	>	final FailingBiFunction r = new FailingBiFunction();
1018	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1019	>
1020	>	g.complete(v2);
1021	>	checkIncomplete(h);
1022	>	f.complete(v1);
1023	>
1024	>	checkCompletedWithWrappedCFException(h);
1025	>	checkCompletedNormally(f, v1);
1026	>	checkCompletedNormally(g, v2);
1027	>	}
1028		}
1029
1030		/**
1031		* thenCombine result completes exceptionally if either source cancelled
1032		*/
1033	<	public void testThenCombine4() {
1034	<	CompletableFuture<Integer> f, g, h;
1033	>	public void testThenCombine_sourceCancelled1() {
1034	>	for (ExecutionMode m : ExecutionMode.values())
1035	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1036	>	for (Integer v1 : new Integer[] { 1, null }) {
1037
1038	<	f = new CompletableFuture<>();
1039	<	g = new CompletableFuture<>();
1040	<	h = f.thenCombine(g, subtract);
1041	<	assertTrue(f.cancel(true));
1038	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1039	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1040	>	final SubtractFunction r = new SubtractFunction();
1041	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1042	>
1043	>	assertTrue(f.cancel(mayInterruptIfRunning));
1044		checkIncomplete(h);
1045	<	g.complete(1);
1045	>	g.complete(v1);
1046	>
1047		checkCompletedWithWrappedCancellationException(h);
1048	+	checkCancelled(f);
1049	+	assertFalse(r.ran());
1050	+	checkCompletedNormally(g, v1);
1051	+	}
1052	+	}
1053
1054	<	f = new CompletableFuture<>();
1055	<	g = new CompletableFuture<>();
1056	<	h = f.thenCombine(g, subtract);
1057	<	assertTrue(g.cancel(true));
1054	>	public void testThenCombine_sourceCancelled2() {
1055	>	for (ExecutionMode m : ExecutionMode.values())
1056	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1057	>	for (Integer v1 : new Integer[] { 1, null }) {
1058	>
1059	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1060	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1061	>	final SubtractFunction r = new SubtractFunction();
1062	>	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1063	>
1064	>	assertTrue(g.cancel(mayInterruptIfRunning));
1065		checkIncomplete(h);
1066	<	f.complete(3);
1066	>	f.complete(v1);
1067	>
1068		checkCompletedWithWrappedCancellationException(h);
1069	+	checkCancelled(g);
1070	+	assertFalse(r.ran());
1071	+	checkCompletedNormally(f, v1);
1072	+	}
1073	+	}
1074	+
1075	+	public void testThenCombine_sourceCancelled3() {
1076	+	for (ExecutionMode m : ExecutionMode.values())
1077	+	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1078	+	for (Integer v1 : new Integer[] { 1, null }) {
1079	+
1080	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
1081	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
1082	+	final SubtractFunction r = new SubtractFunction();
1083	+
1084	+	assertTrue(g.cancel(mayInterruptIfRunning));
1085	+	f.complete(v1);
1086	+	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1087	+
1088	+	checkCompletedWithWrappedCancellationException(h);
1089	+	checkCancelled(g);
1090	+	assertFalse(r.ran());
1091	+	checkCompletedNormally(f, v1);
1092	+	}
1093	+	}
1094	+
1095	+	public void testThenCombine_sourceCancelled4() {
1096	+	for (ExecutionMode m : ExecutionMode.values())
1097	+	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1098	+	for (Integer v1 : new Integer[] { 1, null }) {
1099	+
1100	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
1101	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
1102	+	final SubtractFunction r = new SubtractFunction();
1103	+
1104	+	assertTrue(f.cancel(mayInterruptIfRunning));
1105	+	g.complete(v1);
1106	+	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1107
802	–	f = new CompletableFuture<>();
803	–	g = new CompletableFuture<>();
804	–	assertTrue(f.cancel(true));
805	–	assertTrue(g.cancel(true));
806	–	h = f.thenCombine(g, subtract);
1108		checkCompletedWithWrappedCancellationException(h);
1109	+	checkCancelled(f);
1110	+	assertFalse(r.ran());
1111	+	checkCompletedNormally(g, v1);
1112	+	}
1113		}
1114
1115		/**
1116		* thenAcceptBoth result completes normally after normal
1117		* completion of sources
1118		*/
1119	<	public void testThenAcceptBoth() {
1120	<	CompletableFuture<Integer> f, g;
1121	<	CompletableFuture<Void> h;
1122	<	SubtractAction r;
1119	>	public void testThenAcceptBoth_normalCompletion1() {
1120	>	for (ExecutionMode m : ExecutionMode.values())
1121	>	for (Integer v1 : new Integer[] { 1, null })
1122	>	for (Integer v2 : new Integer[] { 2, null }) {
1123
1124	<	f = new CompletableFuture<>();
1125	<	g = new CompletableFuture<>();
1126	<	h = f.thenAcceptBoth(g, r = new SubtractAction());
1127	<	f.complete(3);
1124	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1125	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1126	>	final SubtractAction r = new SubtractAction();
1127	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1128	>
1129	>	f.complete(v1);
1130		checkIncomplete(h);
1131	<	g.complete(1);
1131	>	assertEquals(r.value, 0);
1132	>	g.complete(v2);
1133	>
1134		checkCompletedNormally(h, null);
1135	<	assertEquals(r.value, 2);
1135	>	assertEquals(r.value, subtract(v1, v2));
1136	>	checkCompletedNormally(f, v1);
1137	>	checkCompletedNormally(g, v2);
1138	>	}
1139	>	}
1140
1141	<	f = new CompletableFuture<>();
1142	<	g = new CompletableFuture<>();
1143	<	h = f.thenAcceptBoth(g, r = new SubtractAction());
1144	<	g.complete(1);
1141	>	public void testThenAcceptBoth_normalCompletion2() {
1142	>	for (ExecutionMode m : ExecutionMode.values())
1143	>	for (Integer v1 : new Integer[] { 1, null })
1144	>	for (Integer v2 : new Integer[] { 2, null }) {
1145	>
1146	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1147	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1148	>	final SubtractAction r = new SubtractAction();
1149	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1150	>
1151	>	g.complete(v2);
1152		checkIncomplete(h);
1153	<	f.complete(3);
1153	>	assertEquals(r.value, 0);
1154	>	f.complete(v1);
1155	>
1156		checkCompletedNormally(h, null);
1157	<	assertEquals(r.value, 2);
1157	>	assertEquals(r.value, subtract(v1, v2));
1158	>	checkCompletedNormally(f, v1);
1159	>	checkCompletedNormally(g, v2);
1160	>	}
1161	>	}
1162	>
1163	>	public void testThenAcceptBoth_normalCompletion3() {
1164	>	for (ExecutionMode m : ExecutionMode.values())
1165	>	for (Integer v1 : new Integer[] { 1, null })
1166	>	for (Integer v2 : new Integer[] { 2, null }) {
1167	>
1168	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1169	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1170	>	final SubtractAction r = new SubtractAction();
1171	>
1172	>	g.complete(v2);
1173	>	f.complete(v1);
1174	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1175
837	–	f = new CompletableFuture<>();
838	–	g = new CompletableFuture<>();
839	–	g.complete(1);
840	–	f.complete(3);
841	–	h = f.thenAcceptBoth(g, r = new SubtractAction());
1176		checkCompletedNormally(h, null);
1177	<	assertEquals(r.value, 2);
1177	>	assertEquals(r.value, subtract(v1, v2));
1178	>	checkCompletedNormally(f, v1);
1179	>	checkCompletedNormally(g, v2);
1180	>	}
1181	>	}
1182	>
1183	>	public void testThenAcceptBoth_normalCompletion4() {
1184	>	for (ExecutionMode m : ExecutionMode.values())
1185	>	for (Integer v1 : new Integer[] { 1, null })
1186	>	for (Integer v2 : new Integer[] { 2, null }) {
1187	>
1188	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1189	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1190	>	final SubtractAction r = new SubtractAction();
1191	>
1192	>	f.complete(v1);
1193	>	g.complete(v2);
1194	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1195	>
1196	>	checkCompletedNormally(h, null);
1197	>	assertEquals(r.value, subtract(v1, v2));
1198	>	checkCompletedNormally(f, v1);
1199	>	checkCompletedNormally(g, v2);
1200	>	}
1201		}
1202
1203		/**
1204		* thenAcceptBoth result completes exceptionally after exceptional
1205		* completion of either source
1206		*/
1207	<	public void testThenAcceptBoth2() {
1208	<	CompletableFuture<Integer> f, g;
1209	<	CompletableFuture<Void> h;
853	<	SubtractAction r;
1207	>	public void testThenAcceptBoth_exceptionalCompletion1() {
1208	>	for (ExecutionMode m : ExecutionMode.values())
1209	>	for (Integer v1 : new Integer[] { 1, null }) {
1210
1211	<	f = new CompletableFuture<>();
1212	<	g = new CompletableFuture<>();
1213	<	h = f.thenAcceptBoth(g, r = new SubtractAction());
1214	<	f.completeExceptionally(new CFException());
1211	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1212	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1213	>	final SubtractAction r = new SubtractAction();
1214	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1215	>	final CFException ex = new CFException();
1216	>
1217	>	f.completeExceptionally(ex);
1218		checkIncomplete(h);
1219	<	g.complete(1);
861	<	checkCompletedWithWrappedCFException(h);
1219	>	g.complete(v1);
1220
1221	<	f = new CompletableFuture<>();
1222	<	g = new CompletableFuture<>();
1223	<	h = f.thenAcceptBoth(g, r = new SubtractAction());
1224	<	g.completeExceptionally(new CFException());
1221	>	checkCompletedWithWrappedCFException(h, ex);
1222	>	checkCompletedWithWrappedCFException(f, ex);
1223	>	assertFalse(r.ran());
1224	>	checkCompletedNormally(g, v1);
1225	>	}
1226	>	}
1227	>
1228	>	public void testThenAcceptBoth_exceptionalCompletion2() {
1229	>	for (ExecutionMode m : ExecutionMode.values())
1230	>	for (Integer v1 : new Integer[] { 1, null }) {
1231	>
1232	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1233	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1234	>	final SubtractAction r = new SubtractAction();
1235	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1236	>	final CFException ex = new CFException();
1237	>
1238	>	g.completeExceptionally(ex);
1239		checkIncomplete(h);
1240	<	f.complete(3);
869	<	checkCompletedWithWrappedCFException(h);
1240	>	f.complete(v1);
1241
1242	<	f = new CompletableFuture<>();
1243	<	g = new CompletableFuture<>();
1244	<	f.complete(3);
1245	<	g.completeExceptionally(new CFException());
1246	<	h = f.thenAcceptBoth(g, r = new SubtractAction());
1247	<	checkCompletedWithWrappedCFException(h);
1242	>	checkCompletedWithWrappedCFException(h, ex);
1243	>	checkCompletedWithWrappedCFException(g, ex);
1244	>	assertFalse(r.ran());
1245	>	checkCompletedNormally(f, v1);
1246	>	}
1247	>	}
1248
1249	<	f = new CompletableFuture<>();
1250	<	g = new CompletableFuture<>();
1251	<	f.completeExceptionally(new CFException());
1252	<	g.complete(3);
1253	<	h = f.thenAcceptBoth(g, r = new SubtractAction());
1254	<	checkCompletedWithWrappedCFException(h);
1249	>	public void testThenAcceptBoth_exceptionalCompletion3() {
1250	>	for (ExecutionMode m : ExecutionMode.values())
1251	>	for (Integer v1 : new Integer[] { 1, null }) {
1252	>
1253	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1254	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1255	>	final SubtractAction r = new SubtractAction();
1256	>	final CFException ex = new CFException();
1257	>
1258	>	g.completeExceptionally(ex);
1259	>	f.complete(v1);
1260	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1261	>
1262	>	checkCompletedWithWrappedCFException(h, ex);
1263	>	checkCompletedWithWrappedCFException(g, ex);
1264	>	assertFalse(r.ran());
1265	>	checkCompletedNormally(f, v1);
1266	>	}
1267	>	}
1268	>
1269	>	public void testThenAcceptBoth_exceptionalCompletion4() {
1270	>	for (ExecutionMode m : ExecutionMode.values())
1271	>	for (Integer v1 : new Integer[] { 1, null }) {
1272	>
1273	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1274	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1275	>	final SubtractAction r = new SubtractAction();
1276	>	final CFException ex = new CFException();
1277	>
1278	>	f.completeExceptionally(ex);
1279	>	g.complete(v1);
1280	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1281	>
1282	>	checkCompletedWithWrappedCFException(h, ex);
1283	>	checkCompletedWithWrappedCFException(f, ex);
1284	>	assertFalse(r.ran());
1285	>	checkCompletedNormally(g, v1);
1286	>	}
1287		}
1288
1289		/**
1290		* thenAcceptBoth result completes exceptionally if action does
1291		*/
1292	<	public void testThenAcceptBoth3() {
1293	<	CompletableFuture<Integer> f, g;
1294	<	CompletableFuture<Void> h;
1295	<	FailingBiConsumer r;
1292	>	public void testThenAcceptBoth_actionFailed1() {
1293	>	for (ExecutionMode m : ExecutionMode.values())
1294	>	for (Integer v1 : new Integer[] { 1, null })
1295	>	for (Integer v2 : new Integer[] { 2, null }) {
1296
1297	<	f = new CompletableFuture<>();
1298	<	g = new CompletableFuture<>();
1299	<	h = f.thenAcceptBoth(g, r = new FailingBiConsumer());
1300	<	f.complete(3);
1297	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1298	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1299	>	final FailingBiConsumer r = new FailingBiConsumer();
1300	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1301	>
1302	>	f.complete(v1);
1303		checkIncomplete(h);
1304	<	g.complete(1);
1304	>	g.complete(v2);
1305	>
1306		checkCompletedWithWrappedCFException(h);
1307	+	checkCompletedNormally(f, v1);
1308	+	checkCompletedNormally(g, v2);
1309	+	}
1310	+	}
1311	+
1312	+	public void testThenAcceptBoth_actionFailed2() {
1313	+	for (ExecutionMode m : ExecutionMode.values())
1314	+	for (Integer v1 : new Integer[] { 1, null })
1315	+	for (Integer v2 : new Integer[] { 2, null }) {
1316	+
1317	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
1318	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
1319	+	final FailingBiConsumer r = new FailingBiConsumer();
1320	+	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1321	+
1322	+	g.complete(v2);
1323	+	checkIncomplete(h);
1324	+	f.complete(v1);
1325
902	–	f = new CompletableFuture<>();
903	–	g = new CompletableFuture<>();
904	–	f.complete(3);
905	–	g.complete(1);
906	–	h = f.thenAcceptBoth(g, r = new FailingBiConsumer());
1326		checkCompletedWithWrappedCFException(h);
1327	+	checkCompletedNormally(f, v1);
1328	+	checkCompletedNormally(g, v2);
1329	+	}
1330		}
1331
1332		/**
1333		* thenAcceptBoth result completes exceptionally if either source cancelled
1334		*/
1335	<	public void testThenAcceptBoth4() {
1336	<	CompletableFuture<Integer> f, g;
1337	<	CompletableFuture<Void> h;
1338	<	SubtractAction r;
1335	>	public void testThenAcceptBoth_sourceCancelled1() {
1336	>	for (ExecutionMode m : ExecutionMode.values())
1337	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1338	>	for (Integer v1 : new Integer[] { 1, null }) {
1339
1340	<	f = new CompletableFuture<>();
1341	<	g = new CompletableFuture<>();
1342	<	h = f.thenAcceptBoth(g, r = new SubtractAction());
1343	<	assertTrue(f.cancel(true));
1340	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1341	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1342	>	final SubtractAction r = new SubtractAction();
1343	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1344	>
1345	>	assertTrue(f.cancel(mayInterruptIfRunning));
1346		checkIncomplete(h);
1347	<	g.complete(1);
1347	>	g.complete(v1);
1348	>
1349		checkCompletedWithWrappedCancellationException(h);
1350	+	checkCancelled(f);
1351	+	assertFalse(r.ran());
1352	+	checkCompletedNormally(g, v1);
1353	+	}
1354	+	}
1355
1356	<	f = new CompletableFuture<>();
1357	<	g = new CompletableFuture<>();
1358	<	h = f.thenAcceptBoth(g, r = new SubtractAction());
1359	<	assertTrue(g.cancel(true));
1356	>	public void testThenAcceptBoth_sourceCancelled2() {
1357	>	for (ExecutionMode m : ExecutionMode.values())
1358	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1359	>	for (Integer v1 : new Integer[] { 1, null }) {
1360	>
1361	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1362	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
1363	>	final SubtractAction r = new SubtractAction();
1364	>	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1365	>
1366	>	assertTrue(g.cancel(mayInterruptIfRunning));
1367		checkIncomplete(h);
1368	<	f.complete(3);
1368	>	f.complete(v1);
1369	>
1370		checkCompletedWithWrappedCancellationException(h);
1371	+	checkCancelled(g);
1372	+	assertFalse(r.ran());
1373	+	checkCompletedNormally(f, v1);
1374	+	}
1375	+	}
1376	+
1377	+	public void testThenAcceptBoth_sourceCancelled3() {
1378	+	for (ExecutionMode m : ExecutionMode.values())
1379	+	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1380	+	for (Integer v1 : new Integer[] { 1, null }) {
1381	+
1382	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
1383	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
1384	+	final SubtractAction r = new SubtractAction();
1385	+
1386	+	assertTrue(g.cancel(mayInterruptIfRunning));
1387	+	f.complete(v1);
1388	+	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1389
934	–	f = new CompletableFuture<>();
935	–	g = new CompletableFuture<>();
936	–	f.complete(3);
937	–	assertTrue(g.cancel(true));
938	–	h = f.thenAcceptBoth(g, r = new SubtractAction());
1390		checkCompletedWithWrappedCancellationException(h);
1391	+	checkCancelled(g);
1392	+	assertFalse(r.ran());
1393	+	checkCompletedNormally(f, v1);
1394	+	}
1395	+	}
1396	+
1397	+	public void testThenAcceptBoth_sourceCancelled4() {
1398	+	for (ExecutionMode m : ExecutionMode.values())
1399	+	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1400	+	for (Integer v1 : new Integer[] { 1, null }) {
1401	+
1402	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
1403	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
1404	+	final SubtractAction r = new SubtractAction();
1405	+
1406	+	assertTrue(f.cancel(mayInterruptIfRunning));
1407	+	g.complete(v1);
1408	+	final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1409
941	–	f = new CompletableFuture<>();
942	–	g = new CompletableFuture<>();
943	–	assertTrue(f.cancel(true));
944	–	g.complete(3);
945	–	h = f.thenAcceptBoth(g, r = new SubtractAction());
1410		checkCompletedWithWrappedCancellationException(h);
1411	+	checkCancelled(f);
1412	+	assertFalse(r.ran());
1413	+	checkCompletedNormally(g, v1);
1414	+	}
1415		}
1416
1417		/**
#	Line 951 | Line 1419 | public class CompletableFutureTest exten
1419		* completion of sources
1420		*/
1421		public void testRunAfterBoth_normalCompletion1() {
1422	+	for (ExecutionMode m : ExecutionMode.values())
1423		for (Integer v1 : new Integer[] { 1, null })
1424		for (Integer v2 : new Integer[] { 2, null }) {
1425
1426		final CompletableFuture<Integer> f = new CompletableFuture<>();
1427		final CompletableFuture<Integer> g = new CompletableFuture<>();
1428		final Noop r = new Noop();
1429	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1429	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1430
1431		f.complete(v1);
1432		checkIncomplete(h);
#	Line 972 | Line 1441 | public class CompletableFutureTest exten
1441		}
1442
1443		public void testRunAfterBoth_normalCompletion2() {
1444	+	for (ExecutionMode m : ExecutionMode.values())
1445		for (Integer v1 : new Integer[] { 1, null })
1446		for (Integer v2 : new Integer[] { 2, null }) {
1447
1448		final CompletableFuture<Integer> f = new CompletableFuture<>();
1449		final CompletableFuture<Integer> g = new CompletableFuture<>();
1450		final Noop r = new Noop();
1451	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1451	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1452
1453		g.complete(v2);
1454		checkIncomplete(h);
#	Line 993 | Line 1463 | public class CompletableFutureTest exten
1463		}
1464
1465		public void testRunAfterBoth_normalCompletion3() {
1466	+	for (ExecutionMode m : ExecutionMode.values())
1467		for (Integer v1 : new Integer[] { 1, null })
1468		for (Integer v2 : new Integer[] { 2, null }) {
1469
#	Line 1002 | Line 1473 | public class CompletableFutureTest exten
1473
1474		g.complete(v2);
1475		f.complete(v1);
1476	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1476	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1477
1478		checkCompletedNormally(h, null);
1479		assertTrue(r.ran);
#	Line 1012 | Line 1483 | public class CompletableFutureTest exten
1483		}
1484
1485		public void testRunAfterBoth_normalCompletion4() {
1486	+	for (ExecutionMode m : ExecutionMode.values())
1487		for (Integer v1 : new Integer[] { 1, null })
1488		for (Integer v2 : new Integer[] { 2, null }) {
1489
#	Line 1021 | Line 1493 | public class CompletableFutureTest exten
1493
1494		f.complete(v1);
1495		g.complete(v2);
1496	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1496	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1497
1498		checkCompletedNormally(h, null);
1499		assertTrue(r.ran);
#	Line 1035 | Line 1507 | public class CompletableFutureTest exten
1507		* completion of either source
1508		*/
1509		public void testRunAfterBoth_exceptionalCompletion1() {
1510	+	for (ExecutionMode m : ExecutionMode.values())
1511		for (Integer v1 : new Integer[] { 1, null }) {
1512
1513		final CompletableFuture<Integer> f = new CompletableFuture<>();
1514		final CompletableFuture<Integer> g = new CompletableFuture<>();
1515		final Noop r = new Noop();
1516	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1516	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1517		final CFException ex = new CFException();
1518
1519		f.completeExceptionally(ex);
#	Line 1055 | Line 1528 | public class CompletableFutureTest exten
1528		}
1529
1530		public void testRunAfterBoth_exceptionalCompletion2() {
1531	+	for (ExecutionMode m : ExecutionMode.values())
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 Noop r = new Noop();
1537	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1537	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1538		final CFException ex = new CFException();
1539
1540		g.completeExceptionally(ex);
#	Line 1075 | Line 1549 | public class CompletableFutureTest exten
1549		}
1550
1551		public void testRunAfterBoth_exceptionalCompletion3() {
1552	+	for (ExecutionMode m : ExecutionMode.values())
1553		for (Integer v1 : new Integer[] { 1, null }) {
1554
1555		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 1084 | Line 1559 | public class CompletableFutureTest exten
1559
1560		g.completeExceptionally(ex);
1561		f.complete(v1);
1562	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1562	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1563
1564		checkCompletedWithWrappedCFException(h, ex);
1565		checkCompletedWithWrappedCFException(g, ex);
#	Line 1094 | Line 1569 | public class CompletableFutureTest exten
1569		}
1570
1571		public void testRunAfterBoth_exceptionalCompletion4() {
1572	+	for (ExecutionMode m : ExecutionMode.values())
1573		for (Integer v1 : new Integer[] { 1, null }) {
1574
1575		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 1103 | Line 1579 | public class CompletableFutureTest exten
1579
1580		f.completeExceptionally(ex);
1581		g.complete(v1);
1582	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1582	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1583
1584		checkCompletedWithWrappedCFException(h, ex);
1585		checkCompletedWithWrappedCFException(f, ex);
#	Line 1116 | Line 1592 | public class CompletableFutureTest exten
1592		* runAfterBoth result completes exceptionally if action does
1593		*/
1594		public void testRunAfterBoth_actionFailed1() {
1595	+	for (ExecutionMode m : ExecutionMode.values())
1596		for (Integer v1 : new Integer[] { 1, null })
1597		for (Integer v2 : new Integer[] { 2, null }) {
1598
1599		final CompletableFuture<Integer> f = new CompletableFuture<>();
1600		final CompletableFuture<Integer> g = new CompletableFuture<>();
1601		final FailingNoop r = new FailingNoop();
1602	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1602	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1603
1604		f.complete(v1);
1605		checkIncomplete(h);
#	Line 1135 | Line 1612 | public class CompletableFutureTest exten
1612		}
1613
1614		public void testRunAfterBoth_actionFailed2() {
1615	+	for (ExecutionMode m : ExecutionMode.values())
1616		for (Integer v1 : new Integer[] { 1, null })
1617		for (Integer v2 : new Integer[] { 2, null }) {
1618
1619		final CompletableFuture<Integer> f = new CompletableFuture<>();
1620		final CompletableFuture<Integer> g = new CompletableFuture<>();
1621		final FailingNoop r = new FailingNoop();
1622	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1622	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1623
1624		g.complete(v2);
1625		checkIncomplete(h);
#	Line 1157 | Line 1635 | public class CompletableFutureTest exten
1635		* runAfterBoth result completes exceptionally if either source cancelled
1636		*/
1637		public void testRunAfterBoth_sourceCancelled1() {
1638	+	for (ExecutionMode m : ExecutionMode.values())
1639		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1640		for (Integer v1 : new Integer[] { 1, null }) {
1641
1642		final CompletableFuture<Integer> f = new CompletableFuture<>();
1643		final CompletableFuture<Integer> g = new CompletableFuture<>();
1644		final Noop r = new Noop();
1645	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1645	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1646
1647		assertTrue(f.cancel(mayInterruptIfRunning));
1648		checkIncomplete(h);
#	Line 1177 | Line 1656 | public class CompletableFutureTest exten
1656		}
1657
1658		public void testRunAfterBoth_sourceCancelled2() {
1659	+	for (ExecutionMode m : ExecutionMode.values())
1660		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1661		for (Integer v1 : new Integer[] { 1, null }) {
1662
1663		final CompletableFuture<Integer> f = new CompletableFuture<>();
1664		final CompletableFuture<Integer> g = new CompletableFuture<>();
1665		final Noop r = new Noop();
1666	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1666	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1667
1668		assertTrue(g.cancel(mayInterruptIfRunning));
1669		checkIncomplete(h);
#	Line 1197 | Line 1677 | public class CompletableFutureTest exten
1677		}
1678
1679		public void testRunAfterBoth_sourceCancelled3() {
1680	+	for (ExecutionMode m : ExecutionMode.values())
1681		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1682		for (Integer v1 : new Integer[] { 1, null }) {
1683
#	Line 1206 | Line 1687 | public class CompletableFutureTest exten
1687
1688		assertTrue(g.cancel(mayInterruptIfRunning));
1689		f.complete(v1);
1690	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1690	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1691
1692		checkCompletedWithWrappedCancellationException(h);
1693		checkCancelled(g);
#	Line 1216 | Line 1697 | public class CompletableFutureTest exten
1697		}
1698
1699		public void testRunAfterBoth_sourceCancelled4() {
1700	+	for (ExecutionMode m : ExecutionMode.values())
1701		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1702		for (Integer v1 : new Integer[] { 1, null }) {
1703
#	Line 1225 | Line 1707 | public class CompletableFutureTest exten
1707
1708		assertTrue(f.cancel(mayInterruptIfRunning));
1709		g.complete(v1);
1710	<	final CompletableFuture<Void> h = f.runAfterBoth(g, r);
1710	>	final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1711
1712		checkCompletedWithWrappedCancellationException(h);
1713		checkCancelled(f);
#	Line 1669 | Line 2151 | public class CompletableFutureTest exten
2151		}
2152
2153		/**
1672	–	* thenCombineAsync result completes normally after normal
1673	–	* completion of sources
1674	–	*/
1675	–	public void testThenCombineAsync() {
1676	–	CompletableFuture<Integer> f, g, h;
1677	–
1678	–	f = new CompletableFuture<>();
1679	–	g = new CompletableFuture<>();
1680	–	h = f.thenCombineAsync(g, subtract);
1681	–	f.complete(3);
1682	–	checkIncomplete(h);
1683	–	g.complete(1);
1684	–	checkCompletedNormally(h, 2);
1685	–
1686	–	f = new CompletableFuture<>();
1687	–	g = new CompletableFuture<>();
1688	–	h = f.thenCombineAsync(g, subtract);
1689	–	g.complete(1);
1690	–	checkIncomplete(h);
1691	–	f.complete(3);
1692	–	checkCompletedNormally(h, 2);
1693	–
1694	–	f = new CompletableFuture<>();
1695	–	g = new CompletableFuture<>();
1696	–	g.complete(1);
1697	–	f.complete(3);
1698	–	h = f.thenCombineAsync(g, subtract);
1699	–	checkCompletedNormally(h, 2);
1700	–	}
1701	–
1702	–	/**
1703	–	* thenCombineAsync result completes exceptionally after exceptional
1704	–	* completion of either source
1705	–	*/
1706	–	public void testThenCombineAsync2() {
1707	–	CompletableFuture<Integer> f, g, h;
1708	–
1709	–	f = new CompletableFuture<>();
1710	–	g = new CompletableFuture<>();
1711	–	h = f.thenCombineAsync(g, subtract);
1712	–	f.completeExceptionally(new CFException());
1713	–	checkIncomplete(h);
1714	–	g.complete(1);
1715	–	checkCompletedWithWrappedCFException(h);
1716	–
1717	–	f = new CompletableFuture<>();
1718	–	g = new CompletableFuture<>();
1719	–	h = f.thenCombineAsync(g, subtract);
1720	–	g.completeExceptionally(new CFException());
1721	–	checkIncomplete(h);
1722	–	f.complete(3);
1723	–	checkCompletedWithWrappedCFException(h);
1724	–
1725	–	f = new CompletableFuture<>();
1726	–	g = new CompletableFuture<>();
1727	–	g.completeExceptionally(new CFException());
1728	–	f.complete(3);
1729	–	h = f.thenCombineAsync(g, subtract);
1730	–	checkCompletedWithWrappedCFException(h);
1731	–	}
1732	–
1733	–	/**
1734	–	* thenCombineAsync result completes exceptionally if action does
1735	–	*/
1736	–	public void testThenCombineAsync3() {
1737	–	CompletableFuture<Integer> f = new CompletableFuture<>();
1738	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
1739	–	FailingBiFunction r = new FailingBiFunction();
1740	–	CompletableFuture<Integer> g = f.thenCombineAsync(f2, r);
1741	–	f.complete(one);
1742	–	checkIncomplete(g);
1743	–	assertFalse(r.ran);
1744	–	f2.complete(two);
1745	–	checkCompletedWithWrappedCFException(g);
1746	–	assertTrue(r.ran);
1747	–	}
1748	–
1749	–	/**
1750	–	* thenCombineAsync result completes exceptionally if either source cancelled
1751	–	*/
1752	–	public void testThenCombineAsync4() {
1753	–	CompletableFuture<Integer> f, g, h;
1754	–
1755	–	f = new CompletableFuture<>();
1756	–	g = new CompletableFuture<>();
1757	–	h = f.thenCombineAsync(g, subtract);
1758	–	assertTrue(f.cancel(true));
1759	–	checkIncomplete(h);
1760	–	g.complete(1);
1761	–	checkCompletedWithWrappedCancellationException(h);
1762	–
1763	–	f = new CompletableFuture<>();
1764	–	g = new CompletableFuture<>();
1765	–	h = f.thenCombineAsync(g, subtract);
1766	–	assertTrue(g.cancel(true));
1767	–	checkIncomplete(h);
1768	–	f.complete(3);
1769	–	checkCompletedWithWrappedCancellationException(h);
1770	–
1771	–	f = new CompletableFuture<>();
1772	–	g = new CompletableFuture<>();
1773	–	g.complete(3);
1774	–	assertTrue(f.cancel(true));
1775	–	h = f.thenCombineAsync(g, subtract);
1776	–	checkCompletedWithWrappedCancellationException(h);
1777	–
1778	–	f = new CompletableFuture<>();
1779	–	g = new CompletableFuture<>();
1780	–	f.complete(3);
1781	–	assertTrue(g.cancel(true));
1782	–	h = f.thenCombineAsync(g, subtract);
1783	–	checkCompletedWithWrappedCancellationException(h);
1784	–	}
1785	–
1786	–	/**
1787	–	* thenAcceptBothAsync result completes normally after normal
1788	–	* completion of sources
1789	–	*/
1790	–	public void testThenAcceptBothAsync() {
1791	–	CompletableFuture<Integer> f, g;
1792	–	CompletableFuture<Void> h;
1793	–	SubtractAction r;
1794	–
1795	–	f = new CompletableFuture<>();
1796	–	g = new CompletableFuture<>();
1797	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1798	–	f.complete(3);
1799	–	checkIncomplete(h);
1800	–	g.complete(1);
1801	–	checkCompletedNormally(h, null);
1802	–	assertEquals(r.value, 2);
1803	–
1804	–	f = new CompletableFuture<>();
1805	–	g = new CompletableFuture<>();
1806	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1807	–	g.complete(1);
1808	–	checkIncomplete(h);
1809	–	f.complete(3);
1810	–	checkCompletedNormally(h, null);
1811	–	assertEquals(r.value, 2);
1812	–
1813	–	f = new CompletableFuture<>();
1814	–	g = new CompletableFuture<>();
1815	–	g.complete(1);
1816	–	f.complete(3);
1817	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1818	–	checkCompletedNormally(h, null);
1819	–	assertEquals(r.value, 2);
1820	–	}
1821	–
1822	–	/**
1823	–	* thenAcceptBothAsync result completes exceptionally after exceptional
1824	–	* completion of source
1825	–	*/
1826	–	public void testThenAcceptBothAsync2() {
1827	–	CompletableFuture<Integer> f, g;
1828	–	CompletableFuture<Void> h;
1829	–	SubtractAction r;
1830	–
1831	–	f = new CompletableFuture<>();
1832	–	g = new CompletableFuture<>();
1833	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1834	–	f.completeExceptionally(new CFException());
1835	–	checkIncomplete(h);
1836	–	g.complete(1);
1837	–	checkCompletedWithWrappedCFException(h);
1838	–
1839	–	f = new CompletableFuture<>();
1840	–	g = new CompletableFuture<>();
1841	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1842	–	g.completeExceptionally(new CFException());
1843	–	checkIncomplete(h);
1844	–	f.complete(3);
1845	–	checkCompletedWithWrappedCFException(h);
1846	–
1847	–	f = new CompletableFuture<>();
1848	–	g = new CompletableFuture<>();
1849	–	f.complete(3);
1850	–	g.completeExceptionally(new CFException());
1851	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1852	–	checkCompletedWithWrappedCFException(h);
1853	–
1854	–	f = new CompletableFuture<>();
1855	–	g = new CompletableFuture<>();
1856	–	f.completeExceptionally(new CFException());
1857	–	g.complete(3);
1858	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1859	–	checkCompletedWithWrappedCFException(h);
1860	–	}
1861	–
1862	–	/**
1863	–	* thenAcceptBothAsync result completes exceptionally if action does
1864	–	*/
1865	–	public void testThenAcceptBothAsync3() {
1866	–	CompletableFuture<Integer> f, g;
1867	–	CompletableFuture<Void> h;
1868	–	FailingBiConsumer r;
1869	–
1870	–	f = new CompletableFuture<>();
1871	–	g = new CompletableFuture<>();
1872	–	h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer());
1873	–	f.complete(3);
1874	–	checkIncomplete(h);
1875	–	g.complete(1);
1876	–	checkCompletedWithWrappedCFException(h);
1877	–
1878	–	f = new CompletableFuture<>();
1879	–	g = new CompletableFuture<>();
1880	–	f.complete(3);
1881	–	g.complete(1);
1882	–	h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer());
1883	–	checkCompletedWithWrappedCFException(h);
1884	–	}
1885	–
1886	–	/**
1887	–	* thenAcceptBothAsync result completes exceptionally if either source cancelled
1888	–	*/
1889	–	public void testThenAcceptBothAsync4() {
1890	–	CompletableFuture<Integer> f, g;
1891	–	CompletableFuture<Void> h;
1892	–	SubtractAction r;
1893	–
1894	–	f = new CompletableFuture<>();
1895	–	g = new CompletableFuture<>();
1896	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1897	–	assertTrue(f.cancel(true));
1898	–	checkIncomplete(h);
1899	–	g.complete(1);
1900	–	checkCompletedWithWrappedCancellationException(h);
1901	–
1902	–	f = new CompletableFuture<>();
1903	–	g = new CompletableFuture<>();
1904	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1905	–	assertTrue(g.cancel(true));
1906	–	checkIncomplete(h);
1907	–	f.complete(3);
1908	–	checkCompletedWithWrappedCancellationException(h);
1909	–
1910	–	f = new CompletableFuture<>();
1911	–	g = new CompletableFuture<>();
1912	–	f.complete(3);
1913	–	assertTrue(g.cancel(true));
1914	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1915	–	checkCompletedWithWrappedCancellationException(h);
1916	–
1917	–	f = new CompletableFuture<>();
1918	–	g = new CompletableFuture<>();
1919	–	assertTrue(f.cancel(true));
1920	–	g.complete(3);
1921	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction());
1922	–	checkCompletedWithWrappedCancellationException(h);
1923	–	}
1924	–
1925	–	/**
1926	–	* runAfterBothAsync result completes normally after normal
1927	–	* completion of sources
1928	–	*/
1929	–	public void testRunAfterBothAsync() {
1930	–	CompletableFuture<Integer> f = new CompletableFuture<>();
1931	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
1932	–	Noop r = new Noop();
1933	–	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1934	–	f.complete(one);
1935	–	checkIncomplete(g);
1936	–	f2.complete(two);
1937	–	checkCompletedNormally(g, null);
1938	–	assertTrue(r.ran);
1939	–	}
1940	–
1941	–	/**
1942	–	* runAfterBothAsync result completes exceptionally after exceptional
1943	–	* completion of source
1944	–	*/
1945	–	public void testRunAfterBothAsync2() {
1946	–	CompletableFuture<Integer> f = new CompletableFuture<>();
1947	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
1948	–	Noop r = new Noop();
1949	–	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1950	–	f.completeExceptionally(new CFException());
1951	–	f2.complete(two);
1952	–	checkCompletedWithWrappedCFException(g);
1953	–
1954	–	r = new Noop();
1955	–	f = new CompletableFuture<>();
1956	–	f2 = new CompletableFuture<>();
1957	–	g = f.runAfterBothAsync(f2, r);
1958	–	f.complete(one);
1959	–	f2.completeExceptionally(new CFException());
1960	–	checkCompletedWithWrappedCFException(g);
1961	–	}
1962	–
1963	–	/**
1964	–	* runAfterBothAsync result completes exceptionally if action does
1965	–	*/
1966	–	public void testRunAfterBothAsync3() {
1967	–	CompletableFuture<Integer> f = new CompletableFuture<>();
1968	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
1969	–	FailingNoop r = new FailingNoop();
1970	–	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1971	–	f.complete(one);
1972	–	checkIncomplete(g);
1973	–	f2.complete(two);
1974	–	checkCompletedWithWrappedCFException(g);
1975	–	}
1976	–
1977	–	/**
1978	–	* runAfterBothAsync result completes exceptionally if either source cancelled
1979	–	*/
1980	–	public void testRunAfterBothAsync4() {
1981	–	CompletableFuture<Integer> f = new CompletableFuture<>();
1982	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
1983	–	Noop r = new Noop();
1984	–	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r);
1985	–	assertTrue(f.cancel(true));
1986	–	f2.complete(two);
1987	–	checkCompletedWithWrappedCancellationException(g);
1988	–
1989	–	r = new Noop();
1990	–	f = new CompletableFuture<>();
1991	–	f2 = new CompletableFuture<>();
1992	–	g = f.runAfterBothAsync(f2, r);
1993	–	f.complete(one);
1994	–	assertTrue(f2.cancel(true));
1995	–	checkCompletedWithWrappedCancellationException(g);
1996	–	}
1997	–
1998	–	/**
2154		* applyToEitherAsync result completes normally after normal
2155		* completion of sources
2156		*/
#	Line 2434 | Line 2589 | public class CompletableFutureTest exten
2589		checkCompletedWithWrappedCancellationException(g);
2590		}
2591
2437	–	/**
2438	–	* thenCombineAsync result completes normally after normal
2439	–	* completion of sources
2440	–	*/
2441	–	public void testThenCombineAsyncE() {
2442	–	CompletableFuture<Integer> f, g, h;
2443	–	ThreadExecutor e = new ThreadExecutor();
2444	–	int count = 0;
2445	–
2446	–	f = new CompletableFuture<>();
2447	–	g = new CompletableFuture<>();
2448	–	h = f.thenCombineAsync(g, subtract, e);
2449	–	f.complete(3);
2450	–	checkIncomplete(h);
2451	–	g.complete(1);
2452	–	checkCompletedNormally(h, 2);
2453	–	assertEquals(++count, e.count.get());
2454	–
2455	–	f = new CompletableFuture<>();
2456	–	g = new CompletableFuture<>();
2457	–	h = f.thenCombineAsync(g, subtract, e);
2458	–	g.complete(1);
2459	–	checkIncomplete(h);
2460	–	f.complete(3);
2461	–	checkCompletedNormally(h, 2);
2462	–	assertEquals(++count, e.count.get());
2463	–
2464	–	f = new CompletableFuture<>();
2465	–	g = new CompletableFuture<>();
2466	–	g.complete(1);
2467	–	f.complete(3);
2468	–	h = f.thenCombineAsync(g, subtract, e);
2469	–	checkCompletedNormally(h, 2);
2470	–	assertEquals(++count, e.count.get());
2471	–	}
2472	–
2473	–	/**
2474	–	* thenCombineAsync result completes exceptionally after exceptional
2475	–	* completion of either source
2476	–	*/
2477	–	public void testThenCombineAsync2E() {
2478	–	CompletableFuture<Integer> f, g, h;
2479	–	ThreadExecutor e = new ThreadExecutor();
2480	–	int count = 0;
2481	–
2482	–	f = new CompletableFuture<>();
2483	–	g = new CompletableFuture<>();
2484	–	h = f.thenCombineAsync(g, subtract, e);
2485	–	f.completeExceptionally(new CFException());
2486	–	checkIncomplete(h);
2487	–	g.complete(1);
2488	–	checkCompletedWithWrappedCFException(h);
2489	–
2490	–	f = new CompletableFuture<>();
2491	–	g = new CompletableFuture<>();
2492	–	h = f.thenCombineAsync(g, subtract, e);
2493	–	g.completeExceptionally(new CFException());
2494	–	checkIncomplete(h);
2495	–	f.complete(3);
2496	–	checkCompletedWithWrappedCFException(h);
2497	–
2498	–	f = new CompletableFuture<>();
2499	–	g = new CompletableFuture<>();
2500	–	g.completeExceptionally(new CFException());
2501	–	h = f.thenCombineAsync(g, subtract, e);
2502	–	checkIncomplete(h);
2503	–	f.complete(3);
2504	–	checkCompletedWithWrappedCFException(h);
2505	–
2506	–	assertEquals(0, e.count.get());
2507	–	}
2508	–
2509	–	/**
2510	–	* thenCombineAsync result completes exceptionally if action does
2511	–	*/
2512	–	public void testThenCombineAsync3E() {
2513	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2514	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2515	–	FailingBiFunction r = new FailingBiFunction();
2516	–	CompletableFuture<Integer> g = f.thenCombineAsync(f2, r, new ThreadExecutor());
2517	–	f.complete(one);
2518	–	checkIncomplete(g);
2519	–	assertFalse(r.ran);
2520	–	f2.complete(two);
2521	–	checkCompletedWithWrappedCFException(g);
2522	–	assertTrue(r.ran);
2523	–	}
2524	–
2525	–	/**
2526	–	* thenCombineAsync result completes exceptionally if either source cancelled
2527	–	*/
2528	–	public void testThenCombineAsync4E() {
2529	–	CompletableFuture<Integer> f, g, h;
2530	–	ThreadExecutor e = new ThreadExecutor();
2531	–
2532	–	f = new CompletableFuture<>();
2533	–	g = new CompletableFuture<>();
2534	–	h = f.thenCombineAsync(g, subtract, e);
2535	–	assertTrue(f.cancel(true));
2536	–	checkIncomplete(h);
2537	–	g.complete(1);
2538	–	checkCompletedWithWrappedCancellationException(h);
2539	–
2540	–	f = new CompletableFuture<>();
2541	–	g = new CompletableFuture<>();
2542	–	h = f.thenCombineAsync(g, subtract, e);
2543	–	assertTrue(g.cancel(true));
2544	–	checkIncomplete(h);
2545	–	f.complete(3);
2546	–	checkCompletedWithWrappedCancellationException(h);
2547	–
2548	–	f = new CompletableFuture<>();
2549	–	g = new CompletableFuture<>();
2550	–	assertTrue(g.cancel(true));
2551	–	h = f.thenCombineAsync(g, subtract, e);
2552	–	checkIncomplete(h);
2553	–	f.complete(3);
2554	–	checkCompletedWithWrappedCancellationException(h);
2555	–
2556	–	f = new CompletableFuture<>();
2557	–	g = new CompletableFuture<>();
2558	–	assertTrue(f.cancel(true));
2559	–	assertTrue(g.cancel(true));
2560	–	h = f.thenCombineAsync(g, subtract, e);
2561	–	checkCompletedWithWrappedCancellationException(h);
2562	–
2563	–	assertEquals(0, e.count.get());
2564	–	}
2565	–
2566	–	/**
2567	–	* thenAcceptBothAsync result completes normally after normal
2568	–	* completion of sources
2569	–	*/
2570	–	public void testThenAcceptBothAsyncE() {
2571	–	CompletableFuture<Integer> f, g;
2572	–	CompletableFuture<Void> h;
2573	–	SubtractAction r;
2574	–	ThreadExecutor e = new ThreadExecutor();
2575	–
2576	–	f = new CompletableFuture<>();
2577	–	g = new CompletableFuture<>();
2578	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2579	–	f.complete(3);
2580	–	checkIncomplete(h);
2581	–	g.complete(1);
2582	–	checkCompletedNormally(h, null);
2583	–	assertEquals(r.value, 2);
2584	–
2585	–	f = new CompletableFuture<>();
2586	–	g = new CompletableFuture<>();
2587	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2588	–	g.complete(1);
2589	–	checkIncomplete(h);
2590	–	f.complete(3);
2591	–	checkCompletedNormally(h, null);
2592	–	assertEquals(r.value, 2);
2593	–
2594	–	f = new CompletableFuture<>();
2595	–	g = new CompletableFuture<>();
2596	–	g.complete(1);
2597	–	f.complete(3);
2598	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2599	–	checkCompletedNormally(h, null);
2600	–	assertEquals(r.value, 2);
2601	–
2602	–	assertEquals(3, e.count.get());
2603	–	}
2604	–
2605	–	/**
2606	–	* thenAcceptBothAsync result completes exceptionally after exceptional
2607	–	* completion of source
2608	–	*/
2609	–	public void testThenAcceptBothAsync2E() {
2610	–	CompletableFuture<Integer> f, g;
2611	–	CompletableFuture<Void> h;
2612	–	SubtractAction r;
2613	–	ThreadExecutor e = new ThreadExecutor();
2614	–
2615	–	f = new CompletableFuture<>();
2616	–	g = new CompletableFuture<>();
2617	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2618	–	f.completeExceptionally(new CFException());
2619	–	checkIncomplete(h);
2620	–	g.complete(1);
2621	–	checkCompletedWithWrappedCFException(h);
2622	–
2623	–	f = new CompletableFuture<>();
2624	–	g = new CompletableFuture<>();
2625	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2626	–	g.completeExceptionally(new CFException());
2627	–	checkIncomplete(h);
2628	–	f.complete(3);
2629	–	checkCompletedWithWrappedCFException(h);
2630	–
2631	–	f = new CompletableFuture<>();
2632	–	g = new CompletableFuture<>();
2633	–	f.complete(3);
2634	–	g.completeExceptionally(new CFException());
2635	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2636	–	checkCompletedWithWrappedCFException(h);
2637	–
2638	–	f = new CompletableFuture<>();
2639	–	g = new CompletableFuture<>();
2640	–	f.completeExceptionally(new CFException());
2641	–	g.complete(3);
2642	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2643	–	checkCompletedWithWrappedCFException(h);
2644	–
2645	–	assertEquals(0, e.count.get());
2646	–	}
2647	–
2648	–	/**
2649	–	* thenAcceptBothAsync result completes exceptionally if action does
2650	–	*/
2651	–	public void testThenAcceptBothAsync3E() {
2652	–	CompletableFuture<Integer> f, g;
2653	–	CompletableFuture<Void> h;
2654	–	FailingBiConsumer r;
2655	–	ThreadExecutor e = new ThreadExecutor();
2656	–
2657	–	f = new CompletableFuture<>();
2658	–	g = new CompletableFuture<>();
2659	–	h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer(), e);
2660	–	f.complete(3);
2661	–	checkIncomplete(h);
2662	–	g.complete(1);
2663	–	checkCompletedWithWrappedCFException(h);
2664	–
2665	–	f = new CompletableFuture<>();
2666	–	g = new CompletableFuture<>();
2667	–	f.complete(3);
2668	–	g.complete(1);
2669	–	h = f.thenAcceptBothAsync(g, r = new FailingBiConsumer(), e);
2670	–	checkCompletedWithWrappedCFException(h);
2671	–
2672	–	assertEquals(2, e.count.get());
2673	–	}
2674	–
2675	–	/**
2676	–	* thenAcceptBothAsync result completes exceptionally if either source cancelled
2677	–	*/
2678	–	public void testThenAcceptBothAsync4E() {
2679	–	CompletableFuture<Integer> f, g;
2680	–	CompletableFuture<Void> h;
2681	–	SubtractAction r;
2682	–	ThreadExecutor e = new ThreadExecutor();
2683	–
2684	–	f = new CompletableFuture<>();
2685	–	g = new CompletableFuture<>();
2686	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2687	–	assertTrue(f.cancel(true));
2688	–	checkIncomplete(h);
2689	–	g.complete(1);
2690	–	checkCompletedWithWrappedCancellationException(h);
2691	–
2692	–	f = new CompletableFuture<>();
2693	–	g = new CompletableFuture<>();
2694	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2695	–	assertTrue(g.cancel(true));
2696	–	checkIncomplete(h);
2697	–	f.complete(3);
2698	–	checkCompletedWithWrappedCancellationException(h);
2699	–
2700	–	f = new CompletableFuture<>();
2701	–	g = new CompletableFuture<>();
2702	–	f.complete(3);
2703	–	assertTrue(g.cancel(true));
2704	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2705	–	checkCompletedWithWrappedCancellationException(h);
2706	–
2707	–	f = new CompletableFuture<>();
2708	–	g = new CompletableFuture<>();
2709	–	assertTrue(f.cancel(true));
2710	–	g.complete(3);
2711	–	h = f.thenAcceptBothAsync(g, r = new SubtractAction(), e);
2712	–	checkCompletedWithWrappedCancellationException(h);
2713	–
2714	–	assertEquals(0, e.count.get());
2715	–	}
2716	–
2717	–	/**
2718	–	* runAfterBothAsync result completes normally after normal
2719	–	* completion of sources
2720	–	*/
2721	–	public void testRunAfterBothAsyncE() {
2722	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2723	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2724	–	Noop r = new Noop();
2725	–	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2726	–	f.complete(one);
2727	–	checkIncomplete(g);
2728	–	f2.complete(two);
2729	–	checkCompletedNormally(g, null);
2730	–	assertTrue(r.ran);
2731	–	}
2732	–
2733	–	/**
2734	–	* runAfterBothAsync result completes exceptionally after exceptional
2735	–	* completion of source
2736	–	*/
2737	–	public void testRunAfterBothAsync2E() {
2738	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2739	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2740	–	Noop r = new Noop();
2741	–	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2742	–	f.completeExceptionally(new CFException());
2743	–	f2.complete(two);
2744	–	checkCompletedWithWrappedCFException(g);
2745	–
2746	–	r = new Noop();
2747	–	f = new CompletableFuture<>();
2748	–	f2 = new CompletableFuture<>();
2749	–	g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2750	–	f.complete(one);
2751	–	f2.completeExceptionally(new CFException());
2752	–	checkCompletedWithWrappedCFException(g);
2753	–	}
2754	–
2755	–	/**
2756	–	* runAfterBothAsync result completes exceptionally if action does
2757	–	*/
2758	–	public void testRunAfterBothAsync3E() {
2759	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2760	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2761	–	FailingNoop r = new FailingNoop();
2762	–	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2763	–	f.complete(one);
2764	–	checkIncomplete(g);
2765	–	f2.complete(two);
2766	–	checkCompletedWithWrappedCFException(g);
2767	–	}
2768	–
2769	–	/**
2770	–	* runAfterBothAsync result completes exceptionally if either source cancelled
2771	–	*/
2772	–	public void testRunAfterBothAsync4E() {
2773	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2774	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2775	–	Noop r = new Noop();
2776	–	CompletableFuture<Void> g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2777	–	assertTrue(f.cancel(true));
2778	–	f2.complete(two);
2779	–	checkCompletedWithWrappedCancellationException(g);
2780	–
2781	–	r = new Noop();
2782	–	f = new CompletableFuture<>();
2783	–	f2 = new CompletableFuture<>();
2784	–	g = f.runAfterBothAsync(f2, r, new ThreadExecutor());
2785	–	f.complete(one);
2786	–	assertTrue(f2.cancel(true));
2787	–	checkCompletedWithWrappedCancellationException(g);
2788	–	}
2789	–
2592		/**
2593		* applyToEitherAsync result completes normally after normal
2594		* completion of sources

Diff Legend

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