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.222 by jsr166, Mon Dec 16 21:18:49 2019 UTC

# Line 926 | Line 926 | public class CompletableFutureTest exten
926          for (boolean createIncomplete : new boolean[] { true, false })
927          for (Integer v1 : new Integer[] { 1, null })
928      {
929 +        final AtomicInteger ran = new AtomicInteger(0);
930          final CompletableFuture<Integer> f = new CompletableFuture<>();
931          if (!createIncomplete) assertTrue(f.complete(v1));
932          final CompletableFuture<Integer> g = m.exceptionally
933              (f, (Throwable t) -> {
934 <                threadFail("should not be called");
935 <                return null;            // unreached
934 >                ran.getAndIncrement();
935 >                throw new AssertionError("should not be called");
936              });
937          if (createIncomplete) assertTrue(f.complete(v1));
938  
939          checkCompletedNormally(g, v1);
940          checkCompletedNormally(f, v1);
941 +        assertEquals(0, ran.get());
942      }}
943  
944      /**
# Line 948 | Line 950 | public class CompletableFutureTest exten
950          for (boolean createIncomplete : new boolean[] { true, false })
951          for (Integer v1 : new Integer[] { 1, null })
952      {
953 <        final AtomicInteger a = new AtomicInteger(0);
953 >        final AtomicInteger ran = new AtomicInteger(0);
954          final CFException ex = new CFException();
955          final CompletableFuture<Integer> f = new CompletableFuture<>();
956          if (!createIncomplete) f.completeExceptionally(ex);
# Line 956 | Line 958 | public class CompletableFutureTest exten
958              (f, (Throwable t) -> {
959                  m.checkExecutionMode();
960                  assertSame(t, ex);
961 <                a.getAndIncrement();
961 >                ran.getAndIncrement();
962                  return v1;
963              });
964          if (createIncomplete) f.completeExceptionally(ex);
965  
966          checkCompletedNormally(g, v1);
967 <        assertEquals(1, a.get());
967 >        assertEquals(1, ran.get());
968      }}
969  
970      /**
# Line 973 | Line 975 | public class CompletableFutureTest exten
975          for (ExecutionMode m : ExecutionMode.values())
976          for (boolean createIncomplete : new boolean[] { true, false })
977      {
978 <        final AtomicInteger a = new AtomicInteger(0);
978 >        final AtomicInteger ran = new AtomicInteger(0);
979          final CFException ex1 = new CFException();
980          final CFException ex2 = new CFException();
981          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 982 | Line 984 | public class CompletableFutureTest exten
984              (f, (Throwable t) -> {
985                  m.checkExecutionMode();
986                  assertSame(t, ex1);
987 <                a.getAndIncrement();
987 >                ran.getAndIncrement();
988                  throw ex2;
989              });
990          if (createIncomplete) f.completeExceptionally(ex1);
991  
992          checkCompletedWithWrappedException(g, ex2);
993          checkCompletedExceptionally(f, ex1);
994 <        assertEquals(1, a.get());
994 >        assertEquals(1, ran.get());
995      }}
996  
997      /**
# Line 1001 | Line 1003 | public class CompletableFutureTest exten
1003          for (boolean createIncomplete : new boolean[] { true, false })
1004          for (Integer v1 : new Integer[] { 1, null })
1005      {
1006 <        final AtomicInteger a = new AtomicInteger(0);
1006 >        final AtomicInteger ran = new AtomicInteger(0);
1007          final CompletableFuture<Integer> f = new CompletableFuture<>();
1008          if (!createIncomplete) assertTrue(f.complete(v1));
1009          final CompletableFuture<Integer> g = m.whenComplete
# Line 1010 | Line 1012 | public class CompletableFutureTest exten
1012                  m.checkExecutionMode();
1013                  assertSame(result, v1);
1014                  assertNull(t);
1015 <                a.getAndIncrement();
1015 >                ran.getAndIncrement();
1016              });
1017          if (createIncomplete) assertTrue(f.complete(v1));
1018  
1019          checkCompletedNormally(g, v1);
1020          checkCompletedNormally(f, v1);
1021 <        assertEquals(1, a.get());
1021 >        assertEquals(1, ran.get());
1022      }}
1023  
1024      /**
# Line 1027 | Line 1029 | public class CompletableFutureTest exten
1029          for (ExecutionMode m : ExecutionMode.values())
1030          for (boolean createIncomplete : new boolean[] { true, false })
1031      {
1032 <        final AtomicInteger a = new AtomicInteger(0);
1032 >        final AtomicInteger ran = new AtomicInteger(0);
1033          final CFException ex = new CFException();
1034          final CompletableFuture<Integer> f = new CompletableFuture<>();
1035          if (!createIncomplete) f.completeExceptionally(ex);
# Line 1037 | Line 1039 | public class CompletableFutureTest exten
1039                  m.checkExecutionMode();
1040                  assertNull(result);
1041                  assertSame(t, ex);
1042 <                a.getAndIncrement();
1042 >                ran.getAndIncrement();
1043              });
1044          if (createIncomplete) f.completeExceptionally(ex);
1045  
1046          checkCompletedWithWrappedException(g, ex);
1047          checkCompletedExceptionally(f, ex);
1048 <        assertEquals(1, a.get());
1048 >        assertEquals(1, ran.get());
1049      }}
1050  
1051      /**
# Line 1055 | Line 1057 | public class CompletableFutureTest exten
1057          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1058          for (boolean createIncomplete : new boolean[] { true, false })
1059      {
1060 <        final AtomicInteger a = new AtomicInteger(0);
1060 >        final AtomicInteger ran = new AtomicInteger(0);
1061          final CompletableFuture<Integer> f = new CompletableFuture<>();
1062          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1063          final CompletableFuture<Integer> g = m.whenComplete
# Line 1064 | Line 1066 | public class CompletableFutureTest exten
1066                  m.checkExecutionMode();
1067                  assertNull(result);
1068                  assertTrue(t instanceof CancellationException);
1069 <                a.getAndIncrement();
1069 >                ran.getAndIncrement();
1070              });
1071          if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1072  
1073          checkCompletedWithWrappedCancellationException(g);
1074          checkCancelled(f);
1075 <        assertEquals(1, a.get());
1075 >        assertEquals(1, ran.get());
1076      }}
1077  
1078      /**
# Line 1082 | Line 1084 | public class CompletableFutureTest exten
1084          for (ExecutionMode m : ExecutionMode.values())
1085          for (Integer v1 : new Integer[] { 1, null })
1086      {
1087 <        final AtomicInteger a = new AtomicInteger(0);
1087 >        final AtomicInteger ran = new AtomicInteger(0);
1088          final CFException ex = new CFException();
1089          final CompletableFuture<Integer> f = new CompletableFuture<>();
1090          if (!createIncomplete) assertTrue(f.complete(v1));
# Line 1092 | Line 1094 | public class CompletableFutureTest exten
1094                  m.checkExecutionMode();
1095                  assertSame(result, v1);
1096                  assertNull(t);
1097 <                a.getAndIncrement();
1097 >                ran.getAndIncrement();
1098                  throw ex;
1099              });
1100          if (createIncomplete) assertTrue(f.complete(v1));
1101  
1102          checkCompletedWithWrappedException(g, ex);
1103          checkCompletedNormally(f, v1);
1104 <        assertEquals(1, a.get());
1104 >        assertEquals(1, ran.get());
1105      }}
1106  
1107      /**
# Line 1111 | Line 1113 | public class CompletableFutureTest exten
1113          for (boolean createIncomplete : new boolean[] { true, false })
1114          for (ExecutionMode m : ExecutionMode.values())
1115      {
1116 <        final AtomicInteger a = new AtomicInteger(0);
1116 >        final AtomicInteger ran = new AtomicInteger(0);
1117          final CFException ex1 = new CFException();
1118          final CFException ex2 = new CFException();
1119          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 1123 | Line 1125 | public class CompletableFutureTest exten
1125                  m.checkExecutionMode();
1126                  assertSame(t, ex1);
1127                  assertNull(result);
1128 <                a.getAndIncrement();
1128 >                ran.getAndIncrement();
1129                  throw ex2;
1130              });
1131          if (createIncomplete) f.completeExceptionally(ex1);
# Line 1134 | Line 1136 | public class CompletableFutureTest exten
1136              assertEquals(1, ex1.getSuppressed().length);
1137              assertSame(ex2, ex1.getSuppressed()[0]);
1138          }
1139 <        assertEquals(1, a.get());
1139 >        assertEquals(1, ran.get());
1140      }}
1141  
1142      /**
# Line 1147 | Line 1149 | public class CompletableFutureTest exten
1149          for (Integer v1 : new Integer[] { 1, null })
1150      {
1151          final CompletableFuture<Integer> f = new CompletableFuture<>();
1152 <        final AtomicInteger a = new AtomicInteger(0);
1152 >        final AtomicInteger ran = new AtomicInteger(0);
1153          if (!createIncomplete) assertTrue(f.complete(v1));
1154          final CompletableFuture<Integer> g = m.handle
1155              (f,
# Line 1155 | Line 1157 | public class CompletableFutureTest exten
1157                  m.checkExecutionMode();
1158                  assertSame(result, v1);
1159                  assertNull(t);
1160 <                a.getAndIncrement();
1160 >                ran.getAndIncrement();
1161                  return inc(v1);
1162              });
1163          if (createIncomplete) assertTrue(f.complete(v1));
1164  
1165          checkCompletedNormally(g, inc(v1));
1166          checkCompletedNormally(f, v1);
1167 <        assertEquals(1, a.get());
1167 >        assertEquals(1, ran.get());
1168      }}
1169  
1170      /**
# Line 1175 | Line 1177 | public class CompletableFutureTest exten
1177          for (Integer v1 : new Integer[] { 1, null })
1178      {
1179          final CompletableFuture<Integer> f = new CompletableFuture<>();
1180 <        final AtomicInteger a = new AtomicInteger(0);
1180 >        final AtomicInteger ran = new AtomicInteger(0);
1181          final CFException ex = new CFException();
1182          if (!createIncomplete) f.completeExceptionally(ex);
1183          final CompletableFuture<Integer> g = m.handle
# Line 1184 | Line 1186 | public class CompletableFutureTest exten
1186                  m.checkExecutionMode();
1187                  assertNull(result);
1188                  assertSame(t, ex);
1189 <                a.getAndIncrement();
1189 >                ran.getAndIncrement();
1190                  return v1;
1191              });
1192          if (createIncomplete) f.completeExceptionally(ex);
1193  
1194          checkCompletedNormally(g, v1);
1195          checkCompletedExceptionally(f, ex);
1196 <        assertEquals(1, a.get());
1196 >        assertEquals(1, ran.get());
1197      }}
1198  
1199      /**
# Line 1205 | Line 1207 | public class CompletableFutureTest exten
1207          for (Integer v1 : new Integer[] { 1, null })
1208      {
1209          final CompletableFuture<Integer> f = new CompletableFuture<>();
1210 <        final AtomicInteger a = new AtomicInteger(0);
1210 >        final AtomicInteger ran = new AtomicInteger(0);
1211          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1212          final CompletableFuture<Integer> g = m.handle
1213              (f,
# Line 1213 | Line 1215 | public class CompletableFutureTest exten
1215                  m.checkExecutionMode();
1216                  assertNull(result);
1217                  assertTrue(t instanceof CancellationException);
1218 <                a.getAndIncrement();
1218 >                ran.getAndIncrement();
1219                  return v1;
1220              });
1221          if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1222  
1223          checkCompletedNormally(g, v1);
1224          checkCancelled(f);
1225 <        assertEquals(1, a.get());
1225 >        assertEquals(1, ran.get());
1226      }}
1227  
1228      /**
# Line 1233 | Line 1235 | public class CompletableFutureTest exten
1235          for (Integer v1 : new Integer[] { 1, null })
1236      {
1237          final CompletableFuture<Integer> f = new CompletableFuture<>();
1238 <        final AtomicInteger a = new AtomicInteger(0);
1238 >        final AtomicInteger ran = new AtomicInteger(0);
1239          final CFException ex = new CFException();
1240          if (!createIncomplete) assertTrue(f.complete(v1));
1241          final CompletableFuture<Integer> g = m.handle
# Line 1242 | Line 1244 | public class CompletableFutureTest exten
1244                  m.checkExecutionMode();
1245                  assertSame(result, v1);
1246                  assertNull(t);
1247 <                a.getAndIncrement();
1247 >                ran.getAndIncrement();
1248                  throw ex;
1249              });
1250          if (createIncomplete) assertTrue(f.complete(v1));
1251  
1252          checkCompletedWithWrappedException(g, ex);
1253          checkCompletedNormally(f, v1);
1254 <        assertEquals(1, a.get());
1254 >        assertEquals(1, ran.get());
1255      }}
1256  
1257      /**
# Line 1261 | Line 1263 | public class CompletableFutureTest exten
1263          for (boolean createIncomplete : new boolean[] { true, false })
1264          for (ExecutionMode m : ExecutionMode.values())
1265      {
1266 <        final AtomicInteger a = new AtomicInteger(0);
1266 >        final AtomicInteger ran = new AtomicInteger(0);
1267          final CFException ex1 = new CFException();
1268          final CFException ex2 = new CFException();
1269          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 1273 | Line 1275 | public class CompletableFutureTest exten
1275                  m.checkExecutionMode();
1276                  assertNull(result);
1277                  assertSame(ex1, t);
1278 <                a.getAndIncrement();
1278 >                ran.getAndIncrement();
1279                  throw ex2;
1280              });
1281          if (createIncomplete) f.completeExceptionally(ex1);
1282  
1283          checkCompletedWithWrappedException(g, ex2);
1284          checkCompletedExceptionally(f, ex1);
1285 <        assertEquals(1, a.get());
1285 >        assertEquals(1, ran.get());
1286      }}
1287  
1288      /**
# Line 3436 | Line 3438 | public class CompletableFutureTest exten
3438          CompletableFuture<Integer> nullFuture = (CompletableFuture<Integer>)null;
3439          ThreadExecutor exec = new ThreadExecutor();
3440  
3441 <        Runnable[] throwingActions = {
3441 >        assertThrows(
3442 >            NullPointerException.class,
3443 >
3444              () -> CompletableFuture.supplyAsync(null),
3445              () -> CompletableFuture.supplyAsync(null, exec),
3446              () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.SYNC, 42), null),
# Line 3539 | Line 3543 | public class CompletableFutureTest exten
3543              () -> f.completeOnTimeout(42, 1L, null),
3544  
3545              () -> CompletableFuture.failedFuture(null),
3546 <            () -> CompletableFuture.failedStage(null),
3543 <        };
3546 >            () -> CompletableFuture.failedStage(null));
3547  
3545 –        assertThrows(NullPointerException.class, throwingActions);
3548          assertEquals(0, exec.count.get());
3549      }
3550  
# Line 4188 | Line 4190 | public class CompletableFutureTest exten
4190              // Manufacture boxed primitives for primitive params
4191              for (int i = 0; i < args.length; i++) {
4192                  Class<?> type = parameterTypes[i];
4193 <                if (parameterTypes[i] == boolean.class)
4194 <                    args[i] = false;
4195 <                else if (parameterTypes[i] == int.class)
4194 <                    args[i] = 0;
4195 <                else if (parameterTypes[i] == long.class)
4196 <                    args[i] = 0L;
4193 >                if      (type == boolean.class) args[i] = false;
4194 >                else if (type == int.class)     args[i] = 0;
4195 >                else if (type == long.class)    args[i] = 0L;
4196              }
4197              for (CompletionStage<Integer> stage : stages) {
4198                  try {
# Line 4829 | Line 4828 | public class CompletableFutureTest exten
4828          for (boolean createIncomplete : new boolean[] { true, false })
4829          for (Integer v1 : new Integer[] { 1, null })
4830      {
4831 +        final AtomicInteger ran = new AtomicInteger(0);
4832          final CompletableFuture<Integer> f = new CompletableFuture<>();
4833          final DelegatedCompletionStage<Integer> d =
4834              new DelegatedCompletionStage<Integer>(f);
4835          if (!createIncomplete) assertTrue(f.complete(v1));
4836          final CompletionStage<Integer> g = d.exceptionallyAsync
4837              ((Throwable t) -> {
4838 <                threadFail("should not be called");
4839 <                return null;            // unreached
4838 >                ran.getAndIncrement();
4839 >                throw new AssertionError("should not be called");
4840              });
4841          if (createIncomplete) assertTrue(f.complete(v1));
4842  
4843          checkCompletedNormally(g.toCompletableFuture(), v1);
4844 +        checkCompletedNormally(f, v1);
4845 +        assertEquals(0, ran.get());
4846      }}
4847  
4848      /**
# Line 4851 | Line 4853 | public class CompletableFutureTest exten
4853          for (boolean createIncomplete : new boolean[] { true, false })
4854          for (Integer v1 : new Integer[] { 1, null })
4855      {
4856 <        final AtomicInteger a = new AtomicInteger(0);
4856 >        final AtomicInteger ran = new AtomicInteger(0);
4857          final CFException ex = new CFException();
4858          final CompletableFuture<Integer> f = new CompletableFuture<>();
4859          final DelegatedCompletionStage<Integer> d =
# Line 4860 | Line 4862 | public class CompletableFutureTest exten
4862          final CompletionStage<Integer> g = d.exceptionallyAsync
4863              ((Throwable t) -> {
4864                  assertSame(t, ex);
4865 <                a.getAndIncrement();
4865 >                ran.getAndIncrement();
4866                  return v1;
4867              });
4868          if (createIncomplete) f.completeExceptionally(ex);
4869  
4870          checkCompletedNormally(g.toCompletableFuture(), v1);
4871 <        assertEquals(1, a.get());
4871 >        checkCompletedExceptionally(f, ex);
4872 >        assertEquals(1, ran.get());
4873      }}
4874  
4875      /**
# Line 4877 | Line 4880 | public class CompletableFutureTest exten
4880      public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4881          for (boolean createIncomplete : new boolean[] { true, false })
4882      {
4883 <        final AtomicInteger a = new AtomicInteger(0);
4883 >        final AtomicInteger ran = new AtomicInteger(0);
4884          final CFException ex1 = new CFException();
4885          final CFException ex2 = new CFException();
4886          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4887 | Line 4890 | public class CompletableFutureTest exten
4890          final CompletionStage<Integer> g = d.exceptionallyAsync
4891              ((Throwable t) -> {
4892                  assertSame(t, ex1);
4893 <                a.getAndIncrement();
4893 >                ran.getAndIncrement();
4894                  throw ex2;
4895              });
4896          if (createIncomplete) f.completeExceptionally(ex1);
# Line 4895 | Line 4898 | public class CompletableFutureTest exten
4898          checkCompletedWithWrappedException(g.toCompletableFuture(), ex2);
4899          checkCompletedExceptionally(f, ex1);
4900          checkCompletedExceptionally(d.toCompletableFuture(), ex1);
4901 <        assertEquals(1, a.get());
4901 >        assertEquals(1, ran.get());
4902      }}
4903  
4904      /**

Diff Legend

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