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.47 by jsr166, Mon Jun 2 18:21:34 2014 UTC vs.
Revision 1.50 by jsr166, Mon Jun 2 19:32:57 2014 UTC

#	Line 17 | Line 17 | 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.ForkJoinPool;
21	+	import java.util.concurrent.ForkJoinTask;
22		import java.util.concurrent.TimeoutException;
23		import java.util.concurrent.atomic.AtomicInteger;
24		import static java.util.concurrent.TimeUnit.MILLISECONDS;
#	Line 414 | Line 416 | public class CompletableFutureTest exten
416		throw new CFException();
417		}
418		}
419	<	static final class FailingNoop implements Runnable {
419	>	static final class FailingRunnable implements Runnable {
420		int invocationCount = 0;
421		public void run() {
422		invocationCount++;
#	Line 458 | Line 460 | public class CompletableFutureTest exten
460		*/
461		enum ExecutionMode {
462		DEFAULT {
463	+	public void checkExecutionMode() {
464	+	assertNull(ForkJoinTask.getPool());
465	+	}
466		public <T> CompletableFuture<Void> thenRun
467		(CompletableFuture<T> f, Runnable a) {
468		return f.thenRun(a);
#	Line 521 | Line 526 | public class CompletableFutureTest exten
526		}
527		},
528
529	<	DEFAULT_ASYNC {
529	>	ASYNC {
530	>	public void checkExecutionMode() {
531	>	assertSame(ForkJoinPool.commonPool(),
532	>	ForkJoinTask.getPool());
533	>	}
534		public <T> CompletableFuture<Void> thenRun
535		(CompletableFuture<T> f, Runnable a) {
536		return f.thenRunAsync(a);
#	Line 586 | Line 595 | public class CompletableFutureTest exten
595		},
596
597		EXECUTOR {
598	+	public void checkExecutionMode() {
599	+	//TODO
600	+	}
601		public <T> CompletableFuture<Void> thenRun
602		(CompletableFuture<T> f, Runnable a) {
603		return f.thenRunAsync(a, new ThreadExecutor());
#	Line 649 | Line 661 | public class CompletableFutureTest exten
661		}
662		};
663
664	+	public abstract void checkExecutionMode();
665		public abstract <T> CompletableFuture<Void> thenRun
666		(CompletableFuture<T> f, Runnable a);
667		public abstract <T> CompletableFuture<Void> thenAccept
#	Line 920 | Line 933 | public class CompletableFutureTest exten
933		* failing runAsync completes exceptionally after running Runnable
934		*/
935		public void testRunAsync3() {
936	<	FailingNoop r = new FailingNoop();
936	>	FailingRunnable r = new FailingRunnable();
937		CompletableFuture<Void> f = CompletableFuture.runAsync(r);
938		checkCompletedWithWrappedCFException(f);
939		assertEquals(1, r.invocationCount);
#	Line 961 | Line 974 | public class CompletableFutureTest exten
974		/**
975		* thenRun result completes normally after normal completion of source
976		*/
977	<	public void testThenRun() {
978	<	CompletableFuture<Integer> f;
979	<	CompletableFuture<Void> g;
980	<	Noop r;
981	<
982	<	f = new CompletableFuture<>();
983	<	g = f.thenRun(r = new Noop());
984	<	f.complete(null);
985	<	checkCompletedNormally(g, null);
986	<	assertEquals(1, r.invocationCount);
977	>	public void testThenRun_normalCompletion() {
978	>	for (ExecutionMode m : ExecutionMode.values())
979	>	for (boolean createIncomplete : new boolean[] { true, false })
980	>	for (Integer v1 : new Integer[] { 1, null })
981	>	{
982	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
983	>	final Noop r = new Noop();
984	>	if (!createIncomplete) f.complete(v1);
985	>	final CompletableFuture<Void> g = m.thenRun(f, r);
986	>	if (createIncomplete) f.complete(v1);
987
975	–	f = new CompletableFuture<>();
976	–	f.complete(null);
977	–	g = f.thenRun(r = new Noop());
988		checkCompletedNormally(g, null);
989	+	checkCompletedNormally(f, v1);
990		assertEquals(1, r.invocationCount);
991	<	}
991	>	}}
992
993		/**
994		* thenRun result completes exceptionally after exceptional
995		* completion of source
996		*/
997	<	public void testThenRun2() {
998	<	CompletableFuture<Integer> f;
999	<	CompletableFuture<Void> g;
1000	<	Noop r;
1001	<
1002	<	f = new CompletableFuture<>();
1003	<	g = f.thenRun(r = new Noop());
1004	<	f.completeExceptionally(new CFException());
1005	<	checkCompletedWithWrappedCFException(g);
1006	<	assertEquals(0, r.invocationCount);
997	>	public void testThenRun_exceptionalCompletion() {
998	>	for (ExecutionMode m : ExecutionMode.values())
999	>	for (boolean createIncomplete : new boolean[] { true, false })
1000	>	{
1001	>	final CFException ex = new CFException();
1002	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1003	>	final Noop r = new Noop();
1004	>	if (!createIncomplete) f.completeExceptionally(ex);
1005	>	final CompletableFuture<Void> g = m.thenRun(f, r);
1006	>	if (createIncomplete) f.completeExceptionally(ex);
1007
1008	<	f = new CompletableFuture<>();
1009	<	f.completeExceptionally(new CFException());
999	<	g = f.thenRun(r = new Noop());
1000	<	checkCompletedWithWrappedCFException(g);
1008	>	checkCompletedWithWrappedCFException(g, ex);
1009	>	checkCompletedWithWrappedCFException(f, ex);
1010		assertEquals(0, r.invocationCount);
1011	<	}
1011	>	}}
1012
1013		/**
1014	<	* thenRun result completes exceptionally if action does
1014	>	* thenRun result completes exceptionally if source cancelled
1015		*/
1016	<	public void testThenRun3() {
1017	<	CompletableFuture<Integer> f;
1018	<	CompletableFuture<Void> g;
1019	<	FailingNoop r;
1020	<
1021	<	f = new CompletableFuture<>();
1022	<	g = f.thenRun(r = new FailingNoop());
1023	<	f.complete(null);
1024	<	checkCompletedWithWrappedCFException(g);
1016	>	public void testThenRun_sourceCancelled() {
1017	>	for (ExecutionMode m : ExecutionMode.values())
1018	>	for (boolean createIncomplete : new boolean[] { true, false })
1019	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1020	>	{
1021	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1022	>	final Noop r = new Noop();
1023	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1024	>	final CompletableFuture<Void> g = f.thenRun(r);
1025	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1026
1027	<	f = new CompletableFuture<>();
1028	<	f.complete(null);
1029	<	g = f.thenRun(r = new FailingNoop());
1030	<	checkCompletedWithWrappedCFException(g);
1021	<	}
1027	>	checkCompletedWithWrappedCancellationException(g);
1028	>	checkCancelled(f);
1029	>	assertEquals(0, r.invocationCount);
1030	>	}}
1031
1032		/**
1033	<	* thenRun result completes exceptionally if source cancelled
1033	>	* thenRun result completes exceptionally if action does
1034		*/
1035	<	public void testThenRun4() {
1036	<	CompletableFuture<Integer> f;
1037	<	CompletableFuture<Void> g;
1038	<	Noop r;
1039	<
1040	<	f = new CompletableFuture<>();
1041	<	g = f.thenRun(r = new Noop());
1042	<	assertTrue(f.cancel(true));
1043	<	checkCompletedWithWrappedCancellationException(g);
1035	>	public void testThenRun_actionFailed() {
1036	>	for (ExecutionMode m : ExecutionMode.values())
1037	>	for (boolean createIncomplete : new boolean[] { true, false })
1038	>	for (Integer v1 : new Integer[] { 1, null })
1039	>	{
1040	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1041	>	final FailingRunnable r = new FailingRunnable();
1042	>	if (!createIncomplete) f.complete(v1);
1043	>	final CompletableFuture<Void> g = f.thenRun(r);
1044	>	if (createIncomplete) f.complete(v1);
1045
1046	<	f = new CompletableFuture<>();
1047	<	assertTrue(f.cancel(true));
1048	<	g = f.thenRun(r = new Noop());
1039	<	checkCompletedWithWrappedCancellationException(g);
1040	<	}
1046	>	checkCompletedWithWrappedCFException(g);
1047	>	checkCompletedNormally(f, v1);
1048	>	}}
1049
1050		/**
1051		* thenApply result completes normally after normal completion of source
1052		*/
1053	<	public void testThenApply() {
1054	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1055	<	CompletableFuture<Integer> g = f.thenApply(inc);
1056	<	f.complete(one);
1057	<	checkCompletedNormally(g, two);
1058	<	}
1053	>	public void testThenApply_normalCompletion() {
1054	>	for (ExecutionMode m : ExecutionMode.values())
1055	>	for (boolean createIncomplete : new boolean[] { true, false })
1056	>	for (Integer v1 : new Integer[] { 1, null })
1057	>	{
1058	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1059	>	final IncFunction r = new IncFunction();
1060	>	if (!createIncomplete) f.complete(v1);
1061	>	final CompletableFuture<Integer> g = m.thenApply(f, r);
1062	>	if (createIncomplete) {
1063	>	checkIncomplete(g);
1064	>	f.complete(v1);
1065	>	}
1066	>
1067	>	checkCompletedNormally(g, inc(v1));
1068	>	checkCompletedNormally(f, v1);
1069	>	assertEquals(1, r.invocationCount);
1070	>	}}
1071
1072		/**
1073		* thenApply result completes exceptionally after exceptional
1074		* completion of source
1075		*/
1076	<	public void testThenApply2() {
1077	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1078	<	CompletableFuture<Integer> g = f.thenApply(inc);
1079	<	f.completeExceptionally(new CFException());
1080	<	checkCompletedWithWrappedCFException(g);
1081	<	}
1076	>	public void testThenApply_exceptionalCompletion() {
1077	>	for (ExecutionMode m : ExecutionMode.values())
1078	>	for (boolean createIncomplete : new boolean[] { true, false })
1079	>	{
1080	>	final CFException ex = new CFException();
1081	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1082	>	final IncFunction r = new IncFunction();
1083	>	if (!createIncomplete) f.completeExceptionally(ex);
1084	>	final CompletableFuture<Integer> g = m.thenApply(f, r);
1085	>	if (createIncomplete) f.completeExceptionally(ex);
1086
1087	<	/**
1088	<	* thenApply result completes exceptionally if action does
1089	<	*/
1090	<	public void testThenApply3() {
1067	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1068	<	CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
1069	<	f.complete(one);
1070	<	checkCompletedWithWrappedCFException(g);
1071	<	}
1087	>	checkCompletedWithWrappedCFException(g, ex);
1088	>	checkCompletedWithWrappedCFException(f, ex);
1089	>	assertEquals(0, r.invocationCount);
1090	>	}}
1091
1092		/**
1093		* thenApply result completes exceptionally if source cancelled
1094		*/
1095	<	public void testThenApply4() {
1096	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1097	<	CompletableFuture<Integer> g = f.thenApply(inc);
1098	<	assertTrue(f.cancel(true));
1095	>	public void testThenApply_sourceCancelled() {
1096	>	for (ExecutionMode m : ExecutionMode.values())
1097	>	for (boolean createIncomplete : new boolean[] { true, false })
1098	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1099	>	{
1100	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1101	>	final IncFunction r = new IncFunction();
1102	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1103	>	final CompletableFuture<Integer> g = f.thenApply(r);
1104	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1105	>
1106		checkCompletedWithWrappedCancellationException(g);
1107	<	}
1107	>	checkCancelled(f);
1108	>	assertEquals(0, r.invocationCount);
1109	>	}}
1110	>
1111	>	/**
1112	>	* thenApply result completes exceptionally if action does
1113	>	*/
1114	>	public void testThenApply_actionFailed() {
1115	>	for (ExecutionMode m : ExecutionMode.values())
1116	>	for (boolean createIncomplete : new boolean[] { true, false })
1117	>	for (Integer v1 : new Integer[] { 1, null })
1118	>	{
1119	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1120	>	final FailingFunction r = new FailingFunction();
1121	>	if (!createIncomplete) f.complete(v1);
1122	>	final CompletableFuture<Integer> g = f.thenApply(r);
1123	>	if (createIncomplete) f.complete(v1);
1124	>
1125	>	checkCompletedWithWrappedCFException(g);
1126	>	checkCompletedNormally(f, v1);
1127	>	}}
1128
1129		/**
1130		* thenAccept result completes normally after normal completion of source
1131		*/
1132	<	public void testThenAccept() {
1133	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1134	<	IncAction r = new IncAction();
1135	<	CompletableFuture<Void> g = f.thenAccept(r);
1136	<	f.complete(one);
1132	>	public void testThenAccept_normalCompletion() {
1133	>	for (ExecutionMode m : ExecutionMode.values())
1134	>	for (boolean createIncomplete : new boolean[] { true, false })
1135	>	for (Integer v1 : new Integer[] { 1, null })
1136	>	{
1137	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1138	>	final IncAction r = new IncAction();
1139	>	if (!createIncomplete) f.complete(v1);
1140	>	final CompletableFuture<Void> g = m.thenAccept(f, r);
1141	>	if (createIncomplete) f.complete(v1);
1142	>
1143		checkCompletedNormally(g, null);
1144	<	assertEquals(r.value, (Integer) 2);
1145	<	}
1144	>	checkCompletedNormally(f, v1);
1145	>	assertEquals(1, r.invocationCount);
1146	>	assertEquals(inc(v1), r.value);
1147	>	}}
1148
1149		/**
1150		* thenAccept result completes exceptionally after exceptional
1151		* completion of source
1152		*/
1153	<	public void testThenAccept2() {
1154	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1155	<	IncAction r = new IncAction();
1156	<	CompletableFuture<Void> g = f.thenAccept(r);
1157	<	f.completeExceptionally(new CFException());
1158	<	checkCompletedWithWrappedCFException(g);
1159	<	}
1153	>	public void testThenAccept_exceptionalCompletion() {
1154	>	for (ExecutionMode m : ExecutionMode.values())
1155	>	for (boolean createIncomplete : new boolean[] { true, false })
1156	>	{
1157	>	final CFException ex = new CFException();
1158	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1159	>	final IncAction r = new IncAction();
1160	>	if (!createIncomplete) f.completeExceptionally(ex);
1161	>	final CompletableFuture<Void> g = m.thenAccept(f, r);
1162	>	if (createIncomplete) f.completeExceptionally(ex);
1163	>
1164	>	checkCompletedWithWrappedCFException(g, ex);
1165	>	checkCompletedWithWrappedCFException(f, ex);
1166	>	assertEquals(0, r.invocationCount);
1167	>	}}
1168
1169		/**
1170		* thenAccept result completes exceptionally if action does
1171		*/
1172	<	public void testThenAccept3() {
1173	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1174	<	FailingConsumer r = new FailingConsumer();
1175	<	CompletableFuture<Void> g = f.thenAccept(r);
1176	<	f.complete(one);
1172	>	public void testThenAccept_actionFailed() {
1173	>	for (ExecutionMode m : ExecutionMode.values())
1174	>	for (boolean createIncomplete : new boolean[] { true, false })
1175	>	for (Integer v1 : new Integer[] { 1, null })
1176	>	{
1177	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1178	>	final FailingConsumer r = new FailingConsumer();
1179	>	if (!createIncomplete) f.complete(v1);
1180	>	final CompletableFuture<Void> g = f.thenAccept(r);
1181	>	if (createIncomplete) f.complete(v1);
1182	>
1183		checkCompletedWithWrappedCFException(g);
1184	<	assertEquals(1, r.invocationCount);
1185	<	}
1184	>	checkCompletedNormally(f, v1);
1185	>	}}
1186
1187		/**
1188		* thenAccept result completes exceptionally if source cancelled
1189		*/
1190	<	public void testThenAccept4() {
1191	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1192	<	IncAction r = new IncAction();
1193	<	CompletableFuture<Void> g = f.thenAccept(r);
1194	<	assertTrue(f.cancel(true));
1190	>	public void testThenAccept_sourceCancelled() {
1191	>	for (ExecutionMode m : ExecutionMode.values())
1192	>	for (boolean createIncomplete : new boolean[] { true, false })
1193	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1194	>	{
1195	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1196	>	final IncAction r = new IncAction();
1197	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1198	>	final CompletableFuture<Void> g = f.thenAccept(r);
1199	>	if (createIncomplete) {
1200	>	checkIncomplete(g);
1201	>	assertTrue(f.cancel(mayInterruptIfRunning));
1202	>	}
1203	>
1204		checkCompletedWithWrappedCancellationException(g);
1205	<	}
1205	>	checkCancelled(f);
1206	>	assertEquals(0, r.invocationCount);
1207	>	}}
1208
1209		/**
1210		* thenCombine result completes normally after normal completion
#	Line 1830 | Line 1909 | public class CompletableFutureTest exten
1909		{
1910		final CompletableFuture<Integer> f = new CompletableFuture<>();
1911		final CompletableFuture<Integer> g = new CompletableFuture<>();
1912	<	final FailingNoop r = new FailingNoop();
1912	>	final FailingRunnable r = new FailingRunnable();
1913		final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1914
1915		f.complete(v1);
#	Line 1849 | Line 1928 | public class CompletableFutureTest exten
1928		{
1929		final CompletableFuture<Integer> f = new CompletableFuture<>();
1930		final CompletableFuture<Integer> g = new CompletableFuture<>();
1931	<	final FailingNoop r = new FailingNoop();
1931	>	final FailingRunnable r = new FailingRunnable();
1932		final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1933
1934		g.complete(v2);
#	Line 2713 | Line 2792 | public class CompletableFutureTest exten
2792		{
2793		final CompletableFuture<Integer> f = new CompletableFuture<>();
2794		final CompletableFuture<Integer> g = new CompletableFuture<>();
2795	<	final FailingNoop r = new FailingNoop();
2795	>	final FailingRunnable r = new FailingRunnable();
2796		final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2797
2798		f.complete(v1);
#	Line 2730 | Line 2809 | public class CompletableFutureTest exten
2809		{
2810		final CompletableFuture<Integer> f = new CompletableFuture<>();
2811		final CompletableFuture<Integer> g = new CompletableFuture<>();
2812	<	final FailingNoop r = new FailingNoop();
2812	>	final FailingRunnable r = new FailingRunnable();
2813		final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2814
2815		g.complete(v2);
#	Line 2840 | Line 2919 | public class CompletableFutureTest exten
2919		/**
2920		* thenCompose result completes normally after normal completion of source
2921		*/
2922	<	public void testThenCompose_normalCompletion1() {
2922	>	public void testThenCompose_normalCompletion() {
2923		for (ExecutionMode m : ExecutionMode.values())
2924	+	for (boolean createIncomplete : new boolean[] { true, false })
2925		for (Integer v1 : new Integer[] { 1, null })
2926		{
2927		final CompletableFuture<Integer> f = new CompletableFuture<>();
2928		final CompletableFutureInc r = new CompletableFutureInc();
2929	+	if (!createIncomplete) f.complete(v1);
2930		final CompletableFuture<Integer> g = f.thenCompose(r);
2931	<	f.complete(v1);
2851	<	checkCompletedNormally(g, inc(v1));
2852	<	checkCompletedNormally(f, v1);
2853	<	assertEquals(1, r.invocationCount);
2854	<	}}
2931	>	if (createIncomplete) f.complete(v1);
2932
2856	–	public void testThenCompose_normalCompletion2() {
2857	–	for (ExecutionMode m : ExecutionMode.values())
2858	–	for (Integer v1 : new Integer[] { 1, null })
2859	–	{
2860	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2861	–	final CompletableFutureInc r = new CompletableFutureInc();
2862	–	f.complete(v1);
2863	–	final CompletableFuture<Integer> g = f.thenCompose(r);
2933		checkCompletedNormally(g, inc(v1));
2934		checkCompletedNormally(f, v1);
2935		assertEquals(1, r.invocationCount);
#	Line 2870 | Line 2939 | public class CompletableFutureTest exten
2939		* thenCompose result completes exceptionally after exceptional
2940		* completion of source
2941		*/
2942	<	public void testThenCompose_exceptionalCompletion1() {
2942	>	public void testThenCompose_exceptionalCompletion() {
2943		for (ExecutionMode m : ExecutionMode.values())
2944	+	for (boolean createIncomplete : new boolean[] { true, false })
2945		{
2946		final CFException ex = new CFException();
2947		final CompletableFutureInc r = new CompletableFutureInc();
2948		final CompletableFuture<Integer> f = new CompletableFuture<>();
2949	+	if (!createIncomplete) f.completeExceptionally(ex);
2950		final CompletableFuture<Integer> g = f.thenCompose(r);
2951	<	f.completeExceptionally(ex);
2881	<	checkCompletedWithWrappedCFException(g, ex);
2882	<	checkCompletedWithWrappedCFException(f, ex);
2883	<	}}
2951	>	if (createIncomplete) f.completeExceptionally(ex);
2952
2885	–	public void testThenCompose_exceptionalCompletion2() {
2886	–	for (ExecutionMode m : ExecutionMode.values())
2887	–	{
2888	–	final CFException ex = new CFException();
2889	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2890	–	f.completeExceptionally(ex);
2891	–	final CompletableFutureInc r = new CompletableFutureInc();
2892	–	final CompletableFuture<Integer> g = f.thenCompose(r);
2953		checkCompletedWithWrappedCFException(g, ex);
2954		checkCompletedWithWrappedCFException(f, ex);
2955	+	assertEquals(0, r.invocationCount);
2956		}}
2957
2958		/**
2959		* thenCompose result completes exceptionally if action does
2960		*/
2961	<	public void testThenCompose_actionFailed1() {
2961	>	public void testThenCompose_actionFailed() {
2962		for (ExecutionMode m : ExecutionMode.values())
2963	+	for (boolean createIncomplete : new boolean[] { true, false })
2964		for (Integer v1 : new Integer[] { 1, null })
2965		{
2966		final CompletableFuture<Integer> f = new CompletableFuture<>();
2967		final FailingCompletableFutureFunction r
2968		= new FailingCompletableFutureFunction();
2969	+	if (!createIncomplete) f.complete(v1);
2970		final CompletableFuture<Integer> g = f.thenCompose(r);
2971	<	f.complete(v1);
2909	<	checkCompletedWithWrappedCFException(g);
2910	<	checkCompletedNormally(f, v1);
2911	<	}}
2971	>	if (createIncomplete) f.complete(v1);
2972
2913	–	public void testThenCompose_actionFailed2() {
2914	–	for (ExecutionMode m : ExecutionMode.values())
2915	–	for (Integer v1 : new Integer[] { 1, null })
2916	–	{
2917	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2918	–	f.complete(v1);
2919	–	final FailingCompletableFutureFunction r
2920	–	= new FailingCompletableFutureFunction();
2921	–	final CompletableFuture<Integer> g = f.thenCompose(r);
2973		checkCompletedWithWrappedCFException(g);
2974		checkCompletedNormally(f, v1);
2975		}}
#	Line 2926 | Line 2977 | public class CompletableFutureTest exten
2977		/**
2978		* thenCompose result completes exceptionally if source cancelled
2979		*/
2980	<	public void testThenCompose_sourceCancelled1() {
2980	>	public void testThenCompose_sourceCancelled() {
2981		for (ExecutionMode m : ExecutionMode.values())
2982	+	for (boolean createIncomplete : new boolean[] { true, false })
2983		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2984		{
2985		final CompletableFuture<Integer> f = new CompletableFuture<>();
2986		final CompletableFutureInc r = new CompletableFutureInc();
2987	+	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2988		final CompletableFuture<Integer> g = f.thenCompose(r);
2989	<	assertTrue(f.cancel(mayInterruptIfRunning));
2990	<	checkCompletedWithWrappedCancellationException(g);
2991	<	checkCancelled(f);
2992	<	}}
2989	>	if (createIncomplete) {
2990	>	checkIncomplete(g);
2991	>	assertTrue(f.cancel(mayInterruptIfRunning));
2992	>	}
2993
2941	–	public void testThenCompose_sourceCancelled2() {
2942	–	for (ExecutionMode m : ExecutionMode.values())
2943	–	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2944	–	{
2945	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2946	–	assertTrue(f.cancel(mayInterruptIfRunning));
2947	–	final CompletableFutureInc r = new CompletableFutureInc();
2948	–	final CompletableFuture<Integer> g = f.thenCompose(r);
2994		checkCompletedWithWrappedCancellationException(g);
2995		checkCancelled(f);
2996		}}
2997
2953	–	// asyncs
2954	–
2955	–	/**
2956	–	* thenRunAsync result completes normally after normal completion of source
2957	–	*/
2958	–	public void testThenRunAsync() {
2959	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2960	–	Noop r = new Noop();
2961	–	CompletableFuture<Void> g = f.thenRunAsync(r);
2962	–	f.complete(null);
2963	–	checkCompletedNormally(g, null);
2964	–
2965	–	// reordered version
2966	–	f = new CompletableFuture<>();
2967	–	f.complete(null);
2968	–	r = new Noop();
2969	–	g = f.thenRunAsync(r);
2970	–	checkCompletedNormally(g, null);
2971	–	}
2972	–
2973	–	/**
2974	–	* thenRunAsync result completes exceptionally after exceptional
2975	–	* completion of source
2976	–	*/
2977	–	public void testThenRunAsync2() {
2978	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2979	–	Noop r = new Noop();
2980	–	CompletableFuture<Void> g = f.thenRunAsync(r);
2981	–	f.completeExceptionally(new CFException());
2982	–	try {
2983	–	g.join();
2984	–	shouldThrow();
2985	–	} catch (CompletionException success) {}
2986	–	checkCompletedWithWrappedCFException(g);
2987	–	}
2988	–
2989	–	/**
2990	–	* thenRunAsync result completes exceptionally if action does
2991	–	*/
2992	–	public void testThenRunAsync3() {
2993	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2994	–	FailingNoop r = new FailingNoop();
2995	–	CompletableFuture<Void> g = f.thenRunAsync(r);
2996	–	f.complete(null);
2997	–	checkCompletedWithWrappedCFException(g);
2998	–	}
2999	–
3000	–	/**
3001	–	* thenRunAsync result completes exceptionally if source cancelled
3002	–	*/
3003	–	public void testThenRunAsync4() {
3004	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3005	–	Noop r = new Noop();
3006	–	CompletableFuture<Void> g = f.thenRunAsync(r);
3007	–	assertTrue(f.cancel(true));
3008	–	checkCompletedWithWrappedCancellationException(g);
3009	–	}
3010	–
3011	–	/**
3012	–	* thenApplyAsync result completes normally after normal completion of source
3013	–	*/
3014	–	public void testThenApplyAsync() {
3015	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3016	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
3017	–	f.complete(one);
3018	–	checkCompletedNormally(g, two);
3019	–	}
3020	–
3021	–	/**
3022	–	* thenApplyAsync result completes exceptionally after exceptional
3023	–	* completion of source
3024	–	*/
3025	–	public void testThenApplyAsync2() {
3026	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3027	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
3028	–	f.completeExceptionally(new CFException());
3029	–	checkCompletedWithWrappedCFException(g);
3030	–	}
3031	–
3032	–	/**
3033	–	* thenApplyAsync result completes exceptionally if action does
3034	–	*/
3035	–	public void testThenApplyAsync3() {
3036	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3037	–	FailingFunction r = new FailingFunction();
3038	–	CompletableFuture<Integer> g = f.thenApplyAsync(r);
3039	–	f.complete(null);
3040	–	checkCompletedWithWrappedCFException(g);
3041	–	}
3042	–
3043	–	/**
3044	–	* thenApplyAsync result completes exceptionally if source cancelled
3045	–	*/
3046	–	public void testThenApplyAsync4() {
3047	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3048	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
3049	–	assertTrue(f.cancel(true));
3050	–	checkCompletedWithWrappedCancellationException(g);
3051	–	}
3052	–
3053	–	/**
3054	–	* thenAcceptAsync result completes normally after normal
3055	–	* completion of source
3056	–	*/
3057	–	public void testThenAcceptAsync() {
3058	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3059	–	IncAction r = new IncAction();
3060	–	CompletableFuture<Void> g = f.thenAcceptAsync(r);
3061	–	f.complete(one);
3062	–	checkCompletedNormally(g, null);
3063	–	assertEquals(r.value, (Integer) 2);
3064	–	}
3065	–
3066	–	/**
3067	–	* thenAcceptAsync result completes exceptionally after exceptional
3068	–	* completion of source
3069	–	*/
3070	–	public void testThenAcceptAsync2() {
3071	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3072	–	IncAction r = new IncAction();
3073	–	CompletableFuture<Void> g = f.thenAcceptAsync(r);
3074	–	f.completeExceptionally(new CFException());
3075	–	checkCompletedWithWrappedCFException(g);
3076	–	}
3077	–
3078	–	/**
3079	–	* thenAcceptAsync result completes exceptionally if action does
3080	–	*/
3081	–	public void testThenAcceptAsync3() {
3082	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3083	–	FailingConsumer r = new FailingConsumer();
3084	–	CompletableFuture<Void> g = f.thenAcceptAsync(r);
3085	–	f.complete(null);
3086	–	checkCompletedWithWrappedCFException(g);
3087	–	}
3088	–
3089	–	/**
3090	–	* thenAcceptAsync result completes exceptionally if source cancelled
3091	–	*/
3092	–	public void testThenAcceptAsync4() {
3093	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3094	–	IncAction r = new IncAction();
3095	–	CompletableFuture<Void> g = f.thenAcceptAsync(r);
3096	–	assertTrue(f.cancel(true));
3097	–	checkCompletedWithWrappedCancellationException(g);
3098	–	}
3099	–
3100	–	// async with explicit executors
3101	–
3102	–	/**
3103	–	* thenRunAsync result completes normally after normal completion of source
3104	–	*/
3105	–	public void testThenRunAsyncE() {
3106	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3107	–	Noop r = new Noop();
3108	–	CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3109	–	f.complete(null);
3110	–	checkCompletedNormally(g, null);
3111	–
3112	–	// reordered version
3113	–	f = new CompletableFuture<>();
3114	–	f.complete(null);
3115	–	r = new Noop();
3116	–	g = f.thenRunAsync(r, new ThreadExecutor());
3117	–	checkCompletedNormally(g, null);
3118	–	}
3119	–
3120	–	/**
3121	–	* thenRunAsync result completes exceptionally after exceptional
3122	–	* completion of source
3123	–	*/
3124	–	public void testThenRunAsync2E() {
3125	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3126	–	Noop r = new Noop();
3127	–	CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3128	–	f.completeExceptionally(new CFException());
3129	–	try {
3130	–	g.join();
3131	–	shouldThrow();
3132	–	} catch (CompletionException success) {}
3133	–	checkCompletedWithWrappedCFException(g);
3134	–	}
3135	–
3136	–	/**
3137	–	* thenRunAsync result completes exceptionally if action does
3138	–	*/
3139	–	public void testThenRunAsync3E() {
3140	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3141	–	FailingNoop r = new FailingNoop();
3142	–	CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3143	–	f.complete(null);
3144	–	checkCompletedWithWrappedCFException(g);
3145	–	}
3146	–
3147	–	/**
3148	–	* thenRunAsync result completes exceptionally if source cancelled
3149	–	*/
3150	–	public void testThenRunAsync4E() {
3151	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3152	–	Noop r = new Noop();
3153	–	CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
3154	–	assertTrue(f.cancel(true));
3155	–	checkCompletedWithWrappedCancellationException(g);
3156	–	}
3157	–
3158	–	/**
3159	–	* thenApplyAsync result completes normally after normal completion of source
3160	–	*/
3161	–	public void testThenApplyAsyncE() {
3162	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3163	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3164	–	f.complete(one);
3165	–	checkCompletedNormally(g, two);
3166	–	}
3167	–
3168	–	/**
3169	–	* thenApplyAsync result completes exceptionally after exceptional
3170	–	* completion of source
3171	–	*/
3172	–	public void testThenApplyAsync2E() {
3173	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3174	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3175	–	f.completeExceptionally(new CFException());
3176	–	checkCompletedWithWrappedCFException(g);
3177	–	}
3178	–
3179	–	/**
3180	–	* thenApplyAsync result completes exceptionally if action does
3181	–	*/
3182	–	public void testThenApplyAsync3E() {
3183	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3184	–	FailingFunction r = new FailingFunction();
3185	–	CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
3186	–	f.complete(null);
3187	–	checkCompletedWithWrappedCFException(g);
3188	–	}
3189	–
3190	–	/**
3191	–	* thenApplyAsync result completes exceptionally if source cancelled
3192	–	*/
3193	–	public void testThenApplyAsync4E() {
3194	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3195	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3196	–	assertTrue(f.cancel(true));
3197	–	checkCompletedWithWrappedCancellationException(g);
3198	–	}
3199	–
3200	–	/**
3201	–	* thenAcceptAsync result completes normally after normal
3202	–	* completion of source
3203	–	*/
3204	–	public void testThenAcceptAsyncE() {
3205	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3206	–	IncAction r = new IncAction();
3207	–	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3208	–	f.complete(one);
3209	–	checkCompletedNormally(g, null);
3210	–	assertEquals(r.value, (Integer) 2);
3211	–	}
3212	–
3213	–	/**
3214	–	* thenAcceptAsync result completes exceptionally after exceptional
3215	–	* completion of source
3216	–	*/
3217	–	public void testThenAcceptAsync2E() {
3218	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3219	–	IncAction r = new IncAction();
3220	–	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3221	–	f.completeExceptionally(new CFException());
3222	–	checkCompletedWithWrappedCFException(g);
3223	–	}
3224	–
3225	–	/**
3226	–	* thenAcceptAsync result completes exceptionally if action does
3227	–	*/
3228	–	public void testThenAcceptAsync3E() {
3229	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3230	–	FailingConsumer r = new FailingConsumer();
3231	–	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3232	–	f.complete(null);
3233	–	checkCompletedWithWrappedCFException(g);
3234	–	}
3235	–
3236	–	/**
3237	–	* thenAcceptAsync result completes exceptionally if source cancelled
3238	–	*/
3239	–	public void testThenAcceptAsync4E() {
3240	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3241	–	IncAction r = new IncAction();
3242	–	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3243	–	assertTrue(f.cancel(true));
3244	–	checkCompletedWithWrappedCancellationException(g);
3245	–	}
3246	–
2998		// other static methods
2999
3000		/**

Diff Legend

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