ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CompletableFutureTest.java
(Generate patch)

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.217 by jsr166, Sat Nov 24 18:13:28 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);
# Line 956 | Line 956 | public class CompletableFutureTest exten
956              (f, (Throwable t) -> {
957                  m.checkExecutionMode();
958                  assertSame(t, ex);
959 <                a.getAndIncrement();
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 982 | Line 982 | public class CompletableFutureTest exten
982              (f, (Throwable t) -> {
983                  m.checkExecutionMode();
984                  assertSame(t, ex1);
985 <                a.getAndIncrement();
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
# Line 1010 | Line 1010 | public class CompletableFutureTest exten
1010                  m.checkExecutionMode();
1011                  assertSame(result, v1);
1012                  assertNull(t);
1013 <                a.getAndIncrement();
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 1037 | Line 1037 | public class CompletableFutureTest exten
1037                  m.checkExecutionMode();
1038                  assertNull(result);
1039                  assertSame(t, ex);
1040 <                a.getAndIncrement();
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
# Line 1064 | Line 1064 | public class CompletableFutureTest exten
1064                  m.checkExecutionMode();
1065                  assertNull(result);
1066                  assertTrue(t instanceof CancellationException);
1067 <                a.getAndIncrement();
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 1092 | Line 1092 | public class CompletableFutureTest exten
1092                  m.checkExecutionMode();
1093                  assertSame(result, v1);
1094                  assertNull(t);
1095 <                a.getAndIncrement();
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 1123 | Line 1123 | public class CompletableFutureTest exten
1123                  m.checkExecutionMode();
1124                  assertSame(t, ex1);
1125                  assertNull(result);
1126 <                a.getAndIncrement();
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,
# Line 1155 | Line 1155 | public class CompletableFutureTest exten
1155                  m.checkExecutionMode();
1156                  assertSame(result, v1);
1157                  assertNull(t);
1158 <                a.getAndIncrement();
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
# Line 1184 | Line 1184 | public class CompletableFutureTest exten
1184                  m.checkExecutionMode();
1185                  assertNull(result);
1186                  assertSame(t, ex);
1187 <                a.getAndIncrement();
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,
# Line 1213 | Line 1213 | public class CompletableFutureTest exten
1213                  m.checkExecutionMode();
1214                  assertNull(result);
1215                  assertTrue(t instanceof CancellationException);
1216 <                a.getAndIncrement();
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
# Line 1242 | Line 1242 | public class CompletableFutureTest exten
1242                  m.checkExecutionMode();
1243                  assertSame(result, v1);
1244                  assertNull(t);
1245 <                a.getAndIncrement();
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 1273 | Line 1273 | public class CompletableFutureTest exten
1273                  m.checkExecutionMode();
1274                  assertNull(result);
1275                  assertSame(ex1, t);
1276 <                a.getAndIncrement();
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 4851 | 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 4860 | Line 4860 | public class CompletableFutureTest exten
4860          final CompletionStage<Integer> g = d.exceptionallyAsync
4861              ((Throwable t) -> {
4862                  assertSame(t, ex);
4863 <                a.getAndIncrement();
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 4877 | 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 4887 | Line 4887 | public class CompletableFutureTest exten
4887          final CompletionStage<Integer> g = d.exceptionallyAsync
4888              ((Throwable t) -> {
4889                  assertSame(t, ex1);
4890 <                a.getAndIncrement();
4890 >                ran.getAndIncrement();
4891                  throw ex2;
4892              });
4893          if (createIncomplete) f.completeExceptionally(ex1);
# Line 4895 | 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      /**

Diff Legend

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