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.208 by jsr166, Sun Sep 23 15:29:31 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);
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 3167 | Line 3169 | public class CompletableFutureTest exten
3169          final CompletableFuture<Integer> g = m.exceptionallyCompose(f, r);
3170          if (createIncomplete) assertTrue(f.complete(v1));
3171  
3170 –        if (!createIncomplete && testImplementationDetails)
3171 –            assertSame(f, g);
3172          checkCompletedNormally(f, v1);
3173          checkCompletedNormally(g, v1);
3174          r.assertNotInvoked();
# Line 3201 | 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 })
3204 –        for (Integer v1 : new Integer[] { 1, null })
3204      {
3205          final CFException ex = new CFException();
3206          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3216 | Line 3215 | public class CompletableFutureTest exten
3215          r.assertInvoked();
3216      }}
3217  
3218 +    /**
3219 +     * exceptionallyCompose result completes exceptionally if the
3220 +     * result of the action does
3221 +     */
3222 +    public void testExceptionallyCompose_actionReturnsFailingFuture() {
3223 +        for (ExecutionMode m : ExecutionMode.values())
3224 +        for (int order = 0; order < 6; order++)
3225 +    {
3226 +        final CFException ex0 = new CFException();
3227 +        final CFException ex = new CFException();
3228 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
3229 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
3230 +        final CompletableFuture<Integer> h;
3231 +        // Test all permutations of orders
3232 +        switch (order) {
3233 +        case 0:
3234 +            assertTrue(f.completeExceptionally(ex0));
3235 +            assertTrue(g.completeExceptionally(ex));
3236 +            h = m.exceptionallyCompose(f, x -> g);
3237 +            break;
3238 +        case 1:
3239 +            assertTrue(f.completeExceptionally(ex0));
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);
3247 +            break;
3248 +        case 3:
3249 +            assertTrue(g.completeExceptionally(ex));
3250 +            h = m.exceptionallyCompose(f, x -> g);
3251 +            assertTrue(f.completeExceptionally(ex0));
3252 +            break;
3253 +        case 4:
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);
3260 +            assertTrue(f.completeExceptionally(ex0));
3261 +            assertTrue(g.completeExceptionally(ex));
3262 +            break;
3263 +        default: throw new AssertionError();
3264 +        }
3265 +
3266 +        checkCompletedExceptionally(g, ex);
3267 +        checkCompletedWithWrappedException(h, ex);
3268 +        checkCompletedExceptionally(f, ex0);
3269 +    }}
3270  
3271      // other static methods
3272  
# Line 3387 | 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 3490 | Line 3543 | public class CompletableFutureTest exten
3543              () -> f.completeOnTimeout(42, 1L, null),
3544  
3545              () -> CompletableFuture.failedFuture(null),
3546 <            () -> CompletableFuture.failedStage(null),
3494 <        };
3546 >            () -> CompletableFuture.failedStage(null));
3547  
3496 –        assertThrows(NullPointerException.class, throwingActions);
3548          assertEquals(0, exec.count.get());
3549      }
3550  
# Line 3596 | Line 3647 | public class CompletableFutureTest exten
3647          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3648          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3649  
3599 –        List<CompletableFuture<?>> futures = new ArrayList<>();
3600 –
3601 –        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3602 –        srcs.add(complete);
3603 –        srcs.add(incomplete);
3604 –
3650          List<CompletableFuture<?>> fs = new ArrayList<>();
3651          fs.add(incomplete.thenRunAsync(() -> {}, e));
3652          fs.add(incomplete.thenAcceptAsync(z -> {}, e));
# Line 4145 | 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)
4151 <                    args[i] = 0;
4152 <                else if (parameterTypes[i] == long.class)
4153 <                    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 4786 | 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 4808 | 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 4816 | Line 4861 | public class CompletableFutureTest exten
4861          if (!createIncomplete) f.completeExceptionally(ex);
4862          final CompletionStage<Integer> g = d.exceptionallyAsync
4863              ((Throwable t) -> {
4864 <                threadAssertSame(t, ex);
4865 <                a.getAndIncrement();
4864 >                assertSame(t, ex);
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 4834 | 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 4843 | Line 4889 | public class CompletableFutureTest exten
4889          if (!createIncomplete) f.completeExceptionally(ex1);
4890          final CompletionStage<Integer> g = d.exceptionallyAsync
4891              ((Throwable t) -> {
4892 <                threadAssertSame(t, ex1);
4893 <                a.getAndIncrement();
4892 >                assertSame(t, ex1);
4893 >                ran.getAndIncrement();
4894                  throw ex2;
4895              });
4896          if (createIncomplete) f.completeExceptionally(ex1);
# Line 4852 | 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      /**
4905 <     * default exceptionallyCompose result completes normally after normal
4906 <     * completion of source
4905 >     * default-implemented exceptionallyCompose result completes
4906 >     * normally after normal completion of source
4907       */
4908      public void testDefaultExceptionallyCompose_normalCompletion() {
4909          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4905 | Line 4951 | public class CompletableFutureTest exten
4951       */
4952      public void testDefaultExceptionallyCompose_actionFailed() {
4953          for (boolean createIncomplete : new boolean[] { true, false })
4908 –        for (Integer v1 : new Integer[] { 1, null })
4954      {
4955          final CFException ex = new CFException();
4956          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4923 | Line 4968 | public class CompletableFutureTest exten
4968      }}
4969  
4970      /**
4971 <     * default exceptionallyComposeAsync result completes normally after normal
4972 <     * completion of source
4971 >     * default-implemented exceptionallyComposeAsync result completes
4972 >     * normally after normal completion of source
4973       */
4974      public void testDefaultExceptionallyComposeAsync_normalCompletion() {
4975          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4972 | Line 5017 | public class CompletableFutureTest exten
5017       */
5018      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5019          for (boolean createIncomplete : new boolean[] { true, false })
4975 –        for (Integer v1 : new Integer[] { 1, null })
5020      {
5021          final CFException ex = new CFException();
5022          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4989 | Line 5033 | public class CompletableFutureTest exten
5033          r.assertInvoked();
5034      }}
5035  
4992 –
5036      /**
5037 <     * default exceptionallyComposeAsync result completes normally after normal
5038 <     * completion of source
5037 >     * default-implemented exceptionallyComposeAsync result completes
5038 >     * normally after normal completion of source
5039       */
5040      public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
5041          for (boolean createIncomplete : new boolean[] { true, false })
# Line 5040 | Line 5083 | public class CompletableFutureTest exten
5083       */
5084      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5085          for (boolean createIncomplete : new boolean[] { true, false })
5043 –        for (Integer v1 : new Integer[] { 1, null })
5086      {
5087          final CFException ex = new CFException();
5088          final CompletableFuture<Integer> f = new CompletableFuture<>();

Diff Legend

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