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.213 by jsr166, Mon Sep 24 17:13:37 2018 UTC vs.
Revision 1.220 by jsr166, Sat Nov 24 21:23:31 2018 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);
957          final CompletableFuture<Integer> g = m.exceptionally
958              (f, (Throwable t) -> {
959                  m.checkExecutionMode();
960 <                threadAssertSame(t, ex);
961 <                a.getAndIncrement();
960 >                assertSame(t, ex);
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 981 | Line 983 | public class CompletableFutureTest exten
983          final CompletableFuture<Integer> g = m.exceptionally
984              (f, (Throwable t) -> {
985                  m.checkExecutionMode();
986 <                threadAssertSame(t, ex1);
987 <                a.getAndIncrement();
986 >                assertSame(t, ex1);
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
1010              (f,
1011               (Integer result, Throwable t) -> {
1012                  m.checkExecutionMode();
1013 <                threadAssertSame(result, v1);
1014 <                threadAssertNull(t);
1015 <                a.getAndIncrement();
1013 >                assertSame(result, v1);
1014 >                assertNull(t);
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 1035 | Line 1037 | public class CompletableFutureTest exten
1037              (f,
1038               (Integer result, Throwable t) -> {
1039                  m.checkExecutionMode();
1040 <                threadAssertNull(result);
1041 <                threadAssertSame(t, ex);
1042 <                a.getAndIncrement();
1040 >                assertNull(result);
1041 >                assertSame(t, ex);
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
1064              (f,
1065               (Integer result, Throwable t) -> {
1066                  m.checkExecutionMode();
1067 <                threadAssertNull(result);
1068 <                threadAssertTrue(t instanceof CancellationException);
1069 <                a.getAndIncrement();
1067 >                assertNull(result);
1068 >                assertTrue(t instanceof CancellationException);
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 1090 | Line 1092 | public class CompletableFutureTest exten
1092              (f,
1093               (Integer result, Throwable t) -> {
1094                  m.checkExecutionMode();
1095 <                threadAssertSame(result, v1);
1096 <                threadAssertNull(t);
1097 <                a.getAndIncrement();
1095 >                assertSame(result, v1);
1096 >                assertNull(t);
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 1121 | Line 1123 | public class CompletableFutureTest exten
1123              (f,
1124               (Integer result, Throwable t) -> {
1125                  m.checkExecutionMode();
1126 <                threadAssertSame(t, ex1);
1127 <                threadAssertNull(result);
1128 <                a.getAndIncrement();
1126 >                assertSame(t, ex1);
1127 >                assertNull(result);
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,
1156               (Integer result, Throwable t) -> {
1157                  m.checkExecutionMode();
1158 <                threadAssertSame(result, v1);
1159 <                threadAssertNull(t);
1160 <                a.getAndIncrement();
1158 >                assertSame(result, v1);
1159 >                assertNull(t);
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
1184              (f,
1185               (Integer result, Throwable t) -> {
1186                  m.checkExecutionMode();
1187 <                threadAssertNull(result);
1188 <                threadAssertSame(t, ex);
1189 <                a.getAndIncrement();
1187 >                assertNull(result);
1188 >                assertSame(t, ex);
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,
1214               (Integer result, Throwable t) -> {
1215                  m.checkExecutionMode();
1216 <                threadAssertNull(result);
1217 <                threadAssertTrue(t instanceof CancellationException);
1218 <                a.getAndIncrement();
1216 >                assertNull(result);
1217 >                assertTrue(t instanceof CancellationException);
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
1242              (f,
1243               (Integer result, Throwable t) -> {
1244                  m.checkExecutionMode();
1245 <                threadAssertSame(result, v1);
1246 <                threadAssertNull(t);
1247 <                a.getAndIncrement();
1245 >                assertSame(result, v1);
1246 >                assertNull(t);
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 1271 | Line 1273 | public class CompletableFutureTest exten
1273              (f,
1274               (Integer result, Throwable t) -> {
1275                  m.checkExecutionMode();
1276 <                threadAssertNull(result);
1277 <                threadAssertSame(ex1, t);
1278 <                a.getAndIncrement();
1276 >                assertNull(result);
1277 >                assertSame(ex1, t);
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 3116 | Line 3118 | public class CompletableFutureTest exten
3118          case 0:
3119              assertTrue(f.complete(v1));
3120              assertTrue(g.completeExceptionally(ex));
3121 <            h = m.thenCompose(f, (x -> g));
3121 >            h = m.thenCompose(f, x -> g);
3122              break;
3123          case 1:
3124              assertTrue(f.complete(v1));
3125 <            h = m.thenCompose(f, (x -> g));
3125 >            h = m.thenCompose(f, x -> g);
3126              assertTrue(g.completeExceptionally(ex));
3127              break;
3128          case 2:
3129              assertTrue(g.completeExceptionally(ex));
3130              assertTrue(f.complete(v1));
3131 <            h = m.thenCompose(f, (x -> g));
3131 >            h = m.thenCompose(f, x -> g);
3132              break;
3133          case 3:
3134              assertTrue(g.completeExceptionally(ex));
3135 <            h = m.thenCompose(f, (x -> g));
3135 >            h = m.thenCompose(f, x -> g);
3136              assertTrue(f.complete(v1));
3137              break;
3138          case 4:
3139 <            h = m.thenCompose(f, (x -> g));
3139 >            h = m.thenCompose(f, x -> g);
3140              assertTrue(f.complete(v1));
3141              assertTrue(g.completeExceptionally(ex));
3142              break;
3143          case 5:
3144 <            h = m.thenCompose(f, (x -> g));
3144 >            h = m.thenCompose(f, x -> g);
3145              assertTrue(f.complete(v1));
3146              assertTrue(g.completeExceptionally(ex));
3147              break;
# Line 3199 | Line 3201 | public class CompletableFutureTest exten
3201      public void testExceptionallyCompose_actionFailed() {
3202          for (ExecutionMode m : ExecutionMode.values())
3203          for (boolean createIncomplete : new boolean[] { true, false })
3202 –        for (Integer v1 : new Integer[] { 1, null })
3204      {
3205          final CFException ex = new CFException();
3206          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3221 | Line 3222 | public class CompletableFutureTest exten
3222      public void testExceptionallyCompose_actionReturnsFailingFuture() {
3223          for (ExecutionMode m : ExecutionMode.values())
3224          for (int order = 0; order < 6; order++)
3224 –        for (Integer v1 : new Integer[] { 1, null })
3225      {
3226          final CFException ex0 = new CFException();
3227          final CFException ex = new CFException();
# Line 3233 | Line 3233 | public class CompletableFutureTest exten
3233          case 0:
3234              assertTrue(f.completeExceptionally(ex0));
3235              assertTrue(g.completeExceptionally(ex));
3236 <            h = m.exceptionallyCompose(f, (x -> g));
3236 >            h = m.exceptionallyCompose(f, x -> g);
3237              break;
3238          case 1:
3239              assertTrue(f.completeExceptionally(ex0));
3240 <            h = m.exceptionallyCompose(f, (x -> g));
3240 >            h = m.exceptionallyCompose(f, x -> g);
3241              assertTrue(g.completeExceptionally(ex));
3242              break;
3243          case 2:
3244              assertTrue(g.completeExceptionally(ex));
3245              assertTrue(f.completeExceptionally(ex0));
3246 <            h = m.exceptionallyCompose(f, (x -> g));
3246 >            h = m.exceptionallyCompose(f, x -> g);
3247              break;
3248          case 3:
3249              assertTrue(g.completeExceptionally(ex));
3250 <            h = m.exceptionallyCompose(f, (x -> g));
3250 >            h = m.exceptionallyCompose(f, x -> g);
3251              assertTrue(f.completeExceptionally(ex0));
3252              break;
3253          case 4:
3254 <            h = m.exceptionallyCompose(f, (x -> g));
3254 >            h = m.exceptionallyCompose(f, x -> g);
3255              assertTrue(f.completeExceptionally(ex0));
3256              assertTrue(g.completeExceptionally(ex));
3257              break;
3258          case 5:
3259 <            h = m.exceptionallyCompose(f, (x -> g));
3259 >            h = m.exceptionallyCompose(f, x -> g);
3260              assertTrue(f.completeExceptionally(ex0));
3261              assertTrue(g.completeExceptionally(ex));
3262              break;
# Line 3647 | Line 3647 | public class CompletableFutureTest exten
3647          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3648          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3649  
3650 –        List<CompletableFuture<?>> futures = new ArrayList<>();
3651 –
3652 –        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3653 –        srcs.add(complete);
3654 –        srcs.add(incomplete);
3655 –
3650          List<CompletableFuture<?>> fs = new ArrayList<>();
3651          fs.add(incomplete.thenRunAsync(() -> {}, e));
3652          fs.add(incomplete.thenAcceptAsync(z -> {}, e));
# Line 4837 | Line 4831 | public class CompletableFutureTest exten
4831          for (boolean createIncomplete : new boolean[] { true, false })
4832          for (Integer v1 : new Integer[] { 1, null })
4833      {
4834 +        final AtomicInteger ran = new AtomicInteger(0);
4835          final CompletableFuture<Integer> f = new CompletableFuture<>();
4836          final DelegatedCompletionStage<Integer> d =
4837              new DelegatedCompletionStage<Integer>(f);
4838          if (!createIncomplete) assertTrue(f.complete(v1));
4839          final CompletionStage<Integer> g = d.exceptionallyAsync
4840              ((Throwable t) -> {
4841 <                threadFail("should not be called");
4842 <                return null;            // unreached
4841 >                ran.getAndIncrement();
4842 >                throw new AssertionError("should not be called");
4843              });
4844          if (createIncomplete) assertTrue(f.complete(v1));
4845  
4846          checkCompletedNormally(g.toCompletableFuture(), v1);
4847 +        checkCompletedNormally(f, v1);
4848 +        assertEquals(0, ran.get());
4849      }}
4850  
4851      /**
# Line 4859 | Line 4856 | public class CompletableFutureTest exten
4856          for (boolean createIncomplete : new boolean[] { true, false })
4857          for (Integer v1 : new Integer[] { 1, null })
4858      {
4859 <        final AtomicInteger a = new AtomicInteger(0);
4859 >        final AtomicInteger ran = new AtomicInteger(0);
4860          final CFException ex = new CFException();
4861          final CompletableFuture<Integer> f = new CompletableFuture<>();
4862          final DelegatedCompletionStage<Integer> d =
# Line 4867 | Line 4864 | public class CompletableFutureTest exten
4864          if (!createIncomplete) f.completeExceptionally(ex);
4865          final CompletionStage<Integer> g = d.exceptionallyAsync
4866              ((Throwable t) -> {
4867 <                threadAssertSame(t, ex);
4868 <                a.getAndIncrement();
4867 >                assertSame(t, ex);
4868 >                ran.getAndIncrement();
4869                  return v1;
4870              });
4871          if (createIncomplete) f.completeExceptionally(ex);
4872  
4873          checkCompletedNormally(g.toCompletableFuture(), v1);
4874 <        assertEquals(1, a.get());
4874 >        checkCompletedExceptionally(f, ex);
4875 >        assertEquals(1, ran.get());
4876      }}
4877  
4878      /**
# Line 4885 | Line 4883 | public class CompletableFutureTest exten
4883      public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4884          for (boolean createIncomplete : new boolean[] { true, false })
4885      {
4886 <        final AtomicInteger a = new AtomicInteger(0);
4886 >        final AtomicInteger ran = new AtomicInteger(0);
4887          final CFException ex1 = new CFException();
4888          final CFException ex2 = new CFException();
4889          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4894 | Line 4892 | public class CompletableFutureTest exten
4892          if (!createIncomplete) f.completeExceptionally(ex1);
4893          final CompletionStage<Integer> g = d.exceptionallyAsync
4894              ((Throwable t) -> {
4895 <                threadAssertSame(t, ex1);
4896 <                a.getAndIncrement();
4895 >                assertSame(t, ex1);
4896 >                ran.getAndIncrement();
4897                  throw ex2;
4898              });
4899          if (createIncomplete) f.completeExceptionally(ex1);
# Line 4903 | Line 4901 | public class CompletableFutureTest exten
4901          checkCompletedWithWrappedException(g.toCompletableFuture(), ex2);
4902          checkCompletedExceptionally(f, ex1);
4903          checkCompletedExceptionally(d.toCompletableFuture(), ex1);
4904 <        assertEquals(1, a.get());
4904 >        assertEquals(1, ran.get());
4905      }}
4906  
4907      /**
# Line 4956 | Line 4954 | public class CompletableFutureTest exten
4954       */
4955      public void testDefaultExceptionallyCompose_actionFailed() {
4956          for (boolean createIncomplete : new boolean[] { true, false })
4959 –        for (Integer v1 : new Integer[] { 1, null })
4957      {
4958          final CFException ex = new CFException();
4959          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 5023 | Line 5020 | public class CompletableFutureTest exten
5020       */
5021      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5022          for (boolean createIncomplete : new boolean[] { true, false })
5026 –        for (Integer v1 : new Integer[] { 1, null })
5023      {
5024          final CFException ex = new CFException();
5025          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 5090 | Line 5086 | public class CompletableFutureTest exten
5086       */
5087      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5088          for (boolean createIncomplete : new boolean[] { true, false })
5093 –        for (Integer v1 : new Integer[] { 1, null })
5089      {
5090          final CFException ex = new CFException();
5091          final CompletableFuture<Integer> f = new CompletableFuture<>();

Diff Legend

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