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.213 by jsr166, Mon Sep 24 17:13:37 2018 UTC vs.
Revision 1.218 by jsr166, Sat Nov 24 18:24:14 2018 UTC

#	Line 948 | Line 948 | public class CompletableFutureTest exten
948		for (boolean createIncomplete : new boolean[] { true, false })
949		for (Integer v1 : new Integer[] { 1, null })
950		{
951	<	final AtomicInteger a = new AtomicInteger(0);
951	>	final AtomicInteger ran = new AtomicInteger(0);
952		final CFException ex = new CFException();
953		final CompletableFuture<Integer> f = new CompletableFuture<>();
954		if (!createIncomplete) f.completeExceptionally(ex);
955		final CompletableFuture<Integer> g = m.exceptionally
956		(f, (Throwable t) -> {
957		m.checkExecutionMode();
958	<	threadAssertSame(t, ex);
959	<	a.getAndIncrement();
958	>	assertSame(t, ex);
959	>	ran.getAndIncrement();
960		return v1;
961		});
962		if (createIncomplete) f.completeExceptionally(ex);
963
964		checkCompletedNormally(g, v1);
965	<	assertEquals(1, a.get());
965	>	assertEquals(1, ran.get());
966		}}
967
968		/**
#	Line 973 | Line 973 | public class CompletableFutureTest exten
973		for (ExecutionMode m : ExecutionMode.values())
974		for (boolean createIncomplete : new boolean[] { true, false })
975		{
976	<	final AtomicInteger a = new AtomicInteger(0);
976	>	final AtomicInteger ran = new AtomicInteger(0);
977		final CFException ex1 = new CFException();
978		final CFException ex2 = new CFException();
979		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 981 | Line 981 | public class CompletableFutureTest exten
981		final CompletableFuture<Integer> g = m.exceptionally
982		(f, (Throwable t) -> {
983		m.checkExecutionMode();
984	<	threadAssertSame(t, ex1);
985	<	a.getAndIncrement();
984	>	assertSame(t, ex1);
985	>	ran.getAndIncrement();
986		throw ex2;
987		});
988		if (createIncomplete) f.completeExceptionally(ex1);
989
990		checkCompletedWithWrappedException(g, ex2);
991		checkCompletedExceptionally(f, ex1);
992	<	assertEquals(1, a.get());
992	>	assertEquals(1, ran.get());
993		}}
994
995		/**
#	Line 1001 | Line 1001 | public class CompletableFutureTest exten
1001		for (boolean createIncomplete : new boolean[] { true, false })
1002		for (Integer v1 : new Integer[] { 1, null })
1003		{
1004	<	final AtomicInteger a = new AtomicInteger(0);
1004	>	final AtomicInteger ran = new AtomicInteger(0);
1005		final CompletableFuture<Integer> f = new CompletableFuture<>();
1006		if (!createIncomplete) assertTrue(f.complete(v1));
1007		final CompletableFuture<Integer> g = m.whenComplete
1008		(f,
1009		(Integer result, Throwable t) -> {
1010		m.checkExecutionMode();
1011	<	threadAssertSame(result, v1);
1012	<	threadAssertNull(t);
1013	<	a.getAndIncrement();
1011	>	assertSame(result, v1);
1012	>	assertNull(t);
1013	>	ran.getAndIncrement();
1014		});
1015		if (createIncomplete) assertTrue(f.complete(v1));
1016
1017		checkCompletedNormally(g, v1);
1018		checkCompletedNormally(f, v1);
1019	<	assertEquals(1, a.get());
1019	>	assertEquals(1, ran.get());
1020		}}
1021
1022		/**
#	Line 1027 | Line 1027 | public class CompletableFutureTest exten
1027		for (ExecutionMode m : ExecutionMode.values())
1028		for (boolean createIncomplete : new boolean[] { true, false })
1029		{
1030	<	final AtomicInteger a = new AtomicInteger(0);
1030	>	final AtomicInteger ran = new AtomicInteger(0);
1031		final CFException ex = new CFException();
1032		final CompletableFuture<Integer> f = new CompletableFuture<>();
1033		if (!createIncomplete) f.completeExceptionally(ex);
#	Line 1035 | Line 1035 | public class CompletableFutureTest exten
1035		(f,
1036		(Integer result, Throwable t) -> {
1037		m.checkExecutionMode();
1038	<	threadAssertNull(result);
1039	<	threadAssertSame(t, ex);
1040	<	a.getAndIncrement();
1038	>	assertNull(result);
1039	>	assertSame(t, ex);
1040	>	ran.getAndIncrement();
1041		});
1042		if (createIncomplete) f.completeExceptionally(ex);
1043
1044		checkCompletedWithWrappedException(g, ex);
1045		checkCompletedExceptionally(f, ex);
1046	<	assertEquals(1, a.get());
1046	>	assertEquals(1, ran.get());
1047		}}
1048
1049		/**
#	Line 1055 | Line 1055 | public class CompletableFutureTest exten
1055		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1056		for (boolean createIncomplete : new boolean[] { true, false })
1057		{
1058	<	final AtomicInteger a = new AtomicInteger(0);
1058	>	final AtomicInteger ran = new AtomicInteger(0);
1059		final CompletableFuture<Integer> f = new CompletableFuture<>();
1060		if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1061		final CompletableFuture<Integer> g = m.whenComplete
1062		(f,
1063		(Integer result, Throwable t) -> {
1064		m.checkExecutionMode();
1065	<	threadAssertNull(result);
1066	<	threadAssertTrue(t instanceof CancellationException);
1067	<	a.getAndIncrement();
1065	>	assertNull(result);
1066	>	assertTrue(t instanceof CancellationException);
1067	>	ran.getAndIncrement();
1068		});
1069		if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1070
1071		checkCompletedWithWrappedCancellationException(g);
1072		checkCancelled(f);
1073	<	assertEquals(1, a.get());
1073	>	assertEquals(1, ran.get());
1074		}}
1075
1076		/**
#	Line 1082 | Line 1082 | public class CompletableFutureTest exten
1082		for (ExecutionMode m : ExecutionMode.values())
1083		for (Integer v1 : new Integer[] { 1, null })
1084		{
1085	<	final AtomicInteger a = new AtomicInteger(0);
1085	>	final AtomicInteger ran = new AtomicInteger(0);
1086		final CFException ex = new CFException();
1087		final CompletableFuture<Integer> f = new CompletableFuture<>();
1088		if (!createIncomplete) assertTrue(f.complete(v1));
#	Line 1090 | Line 1090 | public class CompletableFutureTest exten
1090		(f,
1091		(Integer result, Throwable t) -> {
1092		m.checkExecutionMode();
1093	<	threadAssertSame(result, v1);
1094	<	threadAssertNull(t);
1095	<	a.getAndIncrement();
1093	>	assertSame(result, v1);
1094	>	assertNull(t);
1095	>	ran.getAndIncrement();
1096		throw ex;
1097		});
1098		if (createIncomplete) assertTrue(f.complete(v1));
1099
1100		checkCompletedWithWrappedException(g, ex);
1101		checkCompletedNormally(f, v1);
1102	<	assertEquals(1, a.get());
1102	>	assertEquals(1, ran.get());
1103		}}
1104
1105		/**
#	Line 1111 | Line 1111 | public class CompletableFutureTest exten
1111		for (boolean createIncomplete : new boolean[] { true, false })
1112		for (ExecutionMode m : ExecutionMode.values())
1113		{
1114	<	final AtomicInteger a = new AtomicInteger(0);
1114	>	final AtomicInteger ran = new AtomicInteger(0);
1115		final CFException ex1 = new CFException();
1116		final CFException ex2 = new CFException();
1117		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 1121 | Line 1121 | public class CompletableFutureTest exten
1121		(f,
1122		(Integer result, Throwable t) -> {
1123		m.checkExecutionMode();
1124	<	threadAssertSame(t, ex1);
1125	<	threadAssertNull(result);
1126	<	a.getAndIncrement();
1124	>	assertSame(t, ex1);
1125	>	assertNull(result);
1126	>	ran.getAndIncrement();
1127		throw ex2;
1128		});
1129		if (createIncomplete) f.completeExceptionally(ex1);
#	Line 1134 | Line 1134 | public class CompletableFutureTest exten
1134		assertEquals(1, ex1.getSuppressed().length);
1135		assertSame(ex2, ex1.getSuppressed()[0]);
1136		}
1137	<	assertEquals(1, a.get());
1137	>	assertEquals(1, ran.get());
1138		}}
1139
1140		/**
#	Line 1147 | Line 1147 | public class CompletableFutureTest exten
1147		for (Integer v1 : new Integer[] { 1, null })
1148		{
1149		final CompletableFuture<Integer> f = new CompletableFuture<>();
1150	<	final AtomicInteger a = new AtomicInteger(0);
1150	>	final AtomicInteger ran = new AtomicInteger(0);
1151		if (!createIncomplete) assertTrue(f.complete(v1));
1152		final CompletableFuture<Integer> g = m.handle
1153		(f,
1154		(Integer result, Throwable t) -> {
1155		m.checkExecutionMode();
1156	<	threadAssertSame(result, v1);
1157	<	threadAssertNull(t);
1158	<	a.getAndIncrement();
1156	>	assertSame(result, v1);
1157	>	assertNull(t);
1158	>	ran.getAndIncrement();
1159		return inc(v1);
1160		});
1161		if (createIncomplete) assertTrue(f.complete(v1));
1162
1163		checkCompletedNormally(g, inc(v1));
1164		checkCompletedNormally(f, v1);
1165	<	assertEquals(1, a.get());
1165	>	assertEquals(1, ran.get());
1166		}}
1167
1168		/**
#	Line 1175 | Line 1175 | public class CompletableFutureTest exten
1175		for (Integer v1 : new Integer[] { 1, null })
1176		{
1177		final CompletableFuture<Integer> f = new CompletableFuture<>();
1178	<	final AtomicInteger a = new AtomicInteger(0);
1178	>	final AtomicInteger ran = new AtomicInteger(0);
1179		final CFException ex = new CFException();
1180		if (!createIncomplete) f.completeExceptionally(ex);
1181		final CompletableFuture<Integer> g = m.handle
1182		(f,
1183		(Integer result, Throwable t) -> {
1184		m.checkExecutionMode();
1185	<	threadAssertNull(result);
1186	<	threadAssertSame(t, ex);
1187	<	a.getAndIncrement();
1185	>	assertNull(result);
1186	>	assertSame(t, ex);
1187	>	ran.getAndIncrement();
1188		return v1;
1189		});
1190		if (createIncomplete) f.completeExceptionally(ex);
1191
1192		checkCompletedNormally(g, v1);
1193		checkCompletedExceptionally(f, ex);
1194	<	assertEquals(1, a.get());
1194	>	assertEquals(1, ran.get());
1195		}}
1196
1197		/**
#	Line 1205 | Line 1205 | public class CompletableFutureTest exten
1205		for (Integer v1 : new Integer[] { 1, null })
1206		{
1207		final CompletableFuture<Integer> f = new CompletableFuture<>();
1208	<	final AtomicInteger a = new AtomicInteger(0);
1208	>	final AtomicInteger ran = new AtomicInteger(0);
1209		if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1210		final CompletableFuture<Integer> g = m.handle
1211		(f,
1212		(Integer result, Throwable t) -> {
1213		m.checkExecutionMode();
1214	<	threadAssertNull(result);
1215	<	threadAssertTrue(t instanceof CancellationException);
1216	<	a.getAndIncrement();
1214	>	assertNull(result);
1215	>	assertTrue(t instanceof CancellationException);
1216	>	ran.getAndIncrement();
1217		return v1;
1218		});
1219		if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1220
1221		checkCompletedNormally(g, v1);
1222		checkCancelled(f);
1223	<	assertEquals(1, a.get());
1223	>	assertEquals(1, ran.get());
1224		}}
1225
1226		/**
#	Line 1233 | Line 1233 | public class CompletableFutureTest exten
1233		for (Integer v1 : new Integer[] { 1, null })
1234		{
1235		final CompletableFuture<Integer> f = new CompletableFuture<>();
1236	<	final AtomicInteger a = new AtomicInteger(0);
1236	>	final AtomicInteger ran = new AtomicInteger(0);
1237		final CFException ex = new CFException();
1238		if (!createIncomplete) assertTrue(f.complete(v1));
1239		final CompletableFuture<Integer> g = m.handle
1240		(f,
1241		(Integer result, Throwable t) -> {
1242		m.checkExecutionMode();
1243	<	threadAssertSame(result, v1);
1244	<	threadAssertNull(t);
1245	<	a.getAndIncrement();
1243	>	assertSame(result, v1);
1244	>	assertNull(t);
1245	>	ran.getAndIncrement();
1246		throw ex;
1247		});
1248		if (createIncomplete) assertTrue(f.complete(v1));
1249
1250		checkCompletedWithWrappedException(g, ex);
1251		checkCompletedNormally(f, v1);
1252	<	assertEquals(1, a.get());
1252	>	assertEquals(1, ran.get());
1253		}}
1254
1255		/**
#	Line 1261 | Line 1261 | public class CompletableFutureTest exten
1261		for (boolean createIncomplete : new boolean[] { true, false })
1262		for (ExecutionMode m : ExecutionMode.values())
1263		{
1264	<	final AtomicInteger a = new AtomicInteger(0);
1264	>	final AtomicInteger ran = new AtomicInteger(0);
1265		final CFException ex1 = new CFException();
1266		final CFException ex2 = new CFException();
1267		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 1271 | Line 1271 | public class CompletableFutureTest exten
1271		(f,
1272		(Integer result, Throwable t) -> {
1273		m.checkExecutionMode();
1274	<	threadAssertNull(result);
1275	<	threadAssertSame(ex1, t);
1276	<	a.getAndIncrement();
1274	>	assertNull(result);
1275	>	assertSame(ex1, t);
1276	>	ran.getAndIncrement();
1277		throw ex2;
1278		});
1279		if (createIncomplete) f.completeExceptionally(ex1);
1280
1281		checkCompletedWithWrappedException(g, ex2);
1282		checkCompletedExceptionally(f, ex1);
1283	<	assertEquals(1, a.get());
1283	>	assertEquals(1, ran.get());
1284		}}
1285
1286		/**
#	Line 3116 | Line 3116 | public class CompletableFutureTest exten
3116		case 0:
3117		assertTrue(f.complete(v1));
3118		assertTrue(g.completeExceptionally(ex));
3119	<	h = m.thenCompose(f, (x -> g));
3119	>	h = m.thenCompose(f, x -> g);
3120		break;
3121		case 1:
3122		assertTrue(f.complete(v1));
3123	<	h = m.thenCompose(f, (x -> g));
3123	>	h = m.thenCompose(f, x -> g);
3124		assertTrue(g.completeExceptionally(ex));
3125		break;
3126		case 2:
3127		assertTrue(g.completeExceptionally(ex));
3128		assertTrue(f.complete(v1));
3129	<	h = m.thenCompose(f, (x -> g));
3129	>	h = m.thenCompose(f, x -> g);
3130		break;
3131		case 3:
3132		assertTrue(g.completeExceptionally(ex));
3133	<	h = m.thenCompose(f, (x -> g));
3133	>	h = m.thenCompose(f, x -> g);
3134		assertTrue(f.complete(v1));
3135		break;
3136		case 4:
3137	<	h = m.thenCompose(f, (x -> g));
3137	>	h = m.thenCompose(f, x -> g);
3138		assertTrue(f.complete(v1));
3139		assertTrue(g.completeExceptionally(ex));
3140		break;
3141		case 5:
3142	<	h = m.thenCompose(f, (x -> g));
3142	>	h = m.thenCompose(f, x -> g);
3143		assertTrue(f.complete(v1));
3144		assertTrue(g.completeExceptionally(ex));
3145		break;
#	Line 3199 | Line 3199 | public class CompletableFutureTest exten
3199		public void testExceptionallyCompose_actionFailed() {
3200		for (ExecutionMode m : ExecutionMode.values())
3201		for (boolean createIncomplete : new boolean[] { true, false })
3202	–	for (Integer v1 : new Integer[] { 1, null })
3202		{
3203		final CFException ex = new CFException();
3204		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 3221 | Line 3220 | public class CompletableFutureTest exten
3220		public void testExceptionallyCompose_actionReturnsFailingFuture() {
3221		for (ExecutionMode m : ExecutionMode.values())
3222		for (int order = 0; order < 6; order++)
3224	–	for (Integer v1 : new Integer[] { 1, null })
3223		{
3224		final CFException ex0 = new CFException();
3225		final CFException ex = new CFException();
#	Line 3233 | Line 3231 | public class CompletableFutureTest exten
3231		case 0:
3232		assertTrue(f.completeExceptionally(ex0));
3233		assertTrue(g.completeExceptionally(ex));
3234	<	h = m.exceptionallyCompose(f, (x -> g));
3234	>	h = m.exceptionallyCompose(f, x -> g);
3235		break;
3236		case 1:
3237		assertTrue(f.completeExceptionally(ex0));
3238	<	h = m.exceptionallyCompose(f, (x -> g));
3238	>	h = m.exceptionallyCompose(f, x -> g);
3239		assertTrue(g.completeExceptionally(ex));
3240		break;
3241		case 2:
3242		assertTrue(g.completeExceptionally(ex));
3243		assertTrue(f.completeExceptionally(ex0));
3244	<	h = m.exceptionallyCompose(f, (x -> g));
3244	>	h = m.exceptionallyCompose(f, x -> g);
3245		break;
3246		case 3:
3247		assertTrue(g.completeExceptionally(ex));
3248	<	h = m.exceptionallyCompose(f, (x -> g));
3248	>	h = m.exceptionallyCompose(f, x -> g);
3249		assertTrue(f.completeExceptionally(ex0));
3250		break;
3251		case 4:
3252	<	h = m.exceptionallyCompose(f, (x -> g));
3252	>	h = m.exceptionallyCompose(f, x -> g);
3253		assertTrue(f.completeExceptionally(ex0));
3254		assertTrue(g.completeExceptionally(ex));
3255		break;
3256		case 5:
3257	<	h = m.exceptionallyCompose(f, (x -> g));
3257	>	h = m.exceptionallyCompose(f, x -> g);
3258		assertTrue(f.completeExceptionally(ex0));
3259		assertTrue(g.completeExceptionally(ex));
3260		break;
#	Line 3647 | Line 3645 | public class CompletableFutureTest exten
3645		final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3646		final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3647
3650	–	List<CompletableFuture<?>> futures = new ArrayList<>();
3651	–
3652	–	List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3653	–	srcs.add(complete);
3654	–	srcs.add(incomplete);
3655	–
3648		List<CompletableFuture<?>> fs = new ArrayList<>();
3649		fs.add(incomplete.thenRunAsync(() -> {}, e));
3650		fs.add(incomplete.thenAcceptAsync(z -> {}, e));
#	Line 4859 | Line 4851 | public class CompletableFutureTest exten
4851		for (boolean createIncomplete : new boolean[] { true, false })
4852		for (Integer v1 : new Integer[] { 1, null })
4853		{
4854	<	final AtomicInteger a = new AtomicInteger(0);
4854	>	final AtomicInteger ran = new AtomicInteger(0);
4855		final CFException ex = new CFException();
4856		final CompletableFuture<Integer> f = new CompletableFuture<>();
4857		final DelegatedCompletionStage<Integer> d =
#	Line 4867 | Line 4859 | public class CompletableFutureTest exten
4859		if (!createIncomplete) f.completeExceptionally(ex);
4860		final CompletionStage<Integer> g = d.exceptionallyAsync
4861		((Throwable t) -> {
4862	<	threadAssertSame(t, ex);
4863	<	a.getAndIncrement();
4862	>	assertSame(t, ex);
4863	>	ran.getAndIncrement();
4864		return v1;
4865		});
4866		if (createIncomplete) f.completeExceptionally(ex);
4867
4868		checkCompletedNormally(g.toCompletableFuture(), v1);
4869	<	assertEquals(1, a.get());
4869	>	assertEquals(1, ran.get());
4870		}}
4871
4872		/**
#	Line 4885 | Line 4877 | public class CompletableFutureTest exten
4877		public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4878		for (boolean createIncomplete : new boolean[] { true, false })
4879		{
4880	<	final AtomicInteger a = new AtomicInteger(0);
4880	>	final AtomicInteger ran = new AtomicInteger(0);
4881		final CFException ex1 = new CFException();
4882		final CFException ex2 = new CFException();
4883		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 4894 | Line 4886 | public class CompletableFutureTest exten
4886		if (!createIncomplete) f.completeExceptionally(ex1);
4887		final CompletionStage<Integer> g = d.exceptionallyAsync
4888		((Throwable t) -> {
4889	<	threadAssertSame(t, ex1);
4890	<	a.getAndIncrement();
4889	>	assertSame(t, ex1);
4890	>	ran.getAndIncrement();
4891		throw ex2;
4892		});
4893		if (createIncomplete) f.completeExceptionally(ex1);
#	Line 4903 | Line 4895 | public class CompletableFutureTest exten
4895		checkCompletedWithWrappedException(g.toCompletableFuture(), ex2);
4896		checkCompletedExceptionally(f, ex1);
4897		checkCompletedExceptionally(d.toCompletableFuture(), ex1);
4898	<	assertEquals(1, a.get());
4898	>	assertEquals(1, ran.get());
4899		}}
4900
4901		/**
#	Line 4956 | Line 4948 | public class CompletableFutureTest exten
4948		*/
4949		public void testDefaultExceptionallyCompose_actionFailed() {
4950		for (boolean createIncomplete : new boolean[] { true, false })
4959	–	for (Integer v1 : new Integer[] { 1, null })
4951		{
4952		final CFException ex = new CFException();
4953		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 5023 | Line 5014 | public class CompletableFutureTest exten
5014		*/
5015		public void testDefaultExceptionallyComposeAsync_actionFailed() {
5016		for (boolean createIncomplete : new boolean[] { true, false })
5026	–	for (Integer v1 : new Integer[] { 1, null })
5017		{
5018		final CFException ex = new CFException();
5019		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 5090 | Line 5080 | public class CompletableFutureTest exten
5080		*/
5081		public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5082		for (boolean createIncomplete : new boolean[] { true, false })
5093	–	for (Integer v1 : new Integer[] { 1, null })
5083		{
5084		final CFException ex = new CFException();
5085		final CompletableFuture<Integer> f = new CompletableFuture<>();

Diff Legend

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