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 |
|
/** |
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<>(); |
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 |
|
/** |
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 |
|
/** |
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); |
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 |
|
/** |
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 |
|
/** |
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)); |
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 |
|
/** |
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<>(); |
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); |
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 |
|
/** |
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 |
|
/** |
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 |
|
/** |
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 |
|
/** |
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 |
|
/** |
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<>(); |
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 |
|
/** |
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 = |
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 |
|
/** |
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<>(); |
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); |
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 |
|
/** |