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.203 by jsr166, Sat Sep 22 22:25:12 2018 UTC vs.
Revision 1.223 by jsr166, Mon Dec 16 22:36:39 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 a = new AtomicInteger(0);
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 <                a.getAndIncrement();
935 <                threadFail("should not be called");
936 <                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, a.get());
941 >        assertEquals(0, ran.get());
942      }}
943  
944      /**
# Line 951 | 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 976 | 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 984 | 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 1004 | 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 1030 | 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 1038 | 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 1058 | 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 1085 | 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 1093 | 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 1114 | 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 1124 | 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 1137 | 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 1150 | 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 1178 | 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 1208 | 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 1236 | 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 1264 | 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 1274 | 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 3119 | 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 3202 | 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 })
3205 –        for (Integer v1 : new Integer[] { 1, null })
3204      {
3205          final CFException ex = new CFException();
3206          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3217 | 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 3388 | 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 3491 | Line 3543 | public class CompletableFutureTest exten
3543              () -> f.completeOnTimeout(42, 1L, null),
3544  
3545              () -> CompletableFuture.failedFuture(null),
3546 <            () -> CompletableFuture.failedStage(null),
3495 <        };
3546 >            () -> CompletableFuture.failedStage(null));
3547  
3497 –        assertThrows(NullPointerException.class, throwingActions);
3548          assertEquals(0, exec.count.get());
3549      }
3550  
# Line 3597 | Line 3647 | public class CompletableFutureTest exten
3647          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3648          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3649  
3600 –        List<CompletableFuture<?>> futures = new ArrayList<>();
3601 –
3602 –        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3603 –        srcs.add(complete);
3604 –        srcs.add(incomplete);
3605 –
3650          List<CompletableFuture<?>> fs = new ArrayList<>();
3651          fs.add(incomplete.thenRunAsync(() -> {}, e));
3652          fs.add(incomplete.thenAcceptAsync(z -> {}, e));
# Line 3708 | Line 3752 | public class CompletableFutureTest exten
3752      }
3753  
3754      /**
3711 –     * failedFuture(null) throws NPE
3712 –     */
3713 –    public void testFailedFuture_null() {
3714 –        try {
3715 –            CompletableFuture<Integer> f = CompletableFuture.failedFuture(null);
3716 –            shouldThrow();
3717 –        } catch (NullPointerException success) {}
3718 –    }
3719 –
3720 –    /**
3755       * copy returns a CompletableFuture that is completed normally,
3756       * with the same value, when source is.
3757       */
# Line 4146 | Line 4180 | public class CompletableFutureTest exten
4180              // Manufacture boxed primitives for primitive params
4181              for (int i = 0; i < args.length; i++) {
4182                  Class<?> type = parameterTypes[i];
4183 <                if (parameterTypes[i] == boolean.class)
4184 <                    args[i] = false;
4185 <                else if (parameterTypes[i] == int.class)
4152 <                    args[i] = 0;
4153 <                else if (parameterTypes[i] == long.class)
4154 <                    args[i] = 0L;
4183 >                if      (type == boolean.class) args[i] = false;
4184 >                else if (type == int.class)     args[i] = 0;
4185 >                else if (type == long.class)    args[i] = 0L;
4186              }
4187              for (CompletionStage<Integer> stage : stages) {
4188                  try {
# Line 4780 | Line 4811 | public class CompletableFutureTest exten
4811      }
4812  
4813      /**
4814 +     * default-implemented exceptionallyAsync action is not invoked when
4815 +     * source completes normally, and source result is propagated
4816 +     */
4817 +    public void testDefaultExceptionallyAsync_normalCompletion() {
4818 +        for (boolean createIncomplete : new boolean[] { true, false })
4819 +        for (Integer v1 : new Integer[] { 1, null })
4820 +    {
4821 +        final AtomicInteger ran = new AtomicInteger(0);
4822 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
4823 +        final DelegatedCompletionStage<Integer> d =
4824 +            new DelegatedCompletionStage<Integer>(f);
4825 +        if (!createIncomplete) assertTrue(f.complete(v1));
4826 +        final CompletionStage<Integer> g = d.exceptionallyAsync
4827 +            ((Throwable t) -> {
4828 +                ran.getAndIncrement();
4829 +                throw new AssertionError("should not be called");
4830 +            });
4831 +        if (createIncomplete) assertTrue(f.complete(v1));
4832 +
4833 +        checkCompletedNormally(g.toCompletableFuture(), v1);
4834 +        checkCompletedNormally(f, v1);
4835 +        assertEquals(0, ran.get());
4836 +    }}
4837 +
4838 +    /**
4839       * default-implemented exceptionallyAsync action completes with
4840       * function value on source exception
4841       */
4842 <    public void testDefaulExceptionallyAsync_exceptionalCompletion() {
4842 >    public void testDefaultExceptionallyAsync_exceptionalCompletion() {
4843          for (boolean createIncomplete : new boolean[] { true, false })
4844          for (Integer v1 : new Integer[] { 1, null })
4845      {
4846 <        final AtomicInteger a = new AtomicInteger(0);
4846 >        final AtomicInteger ran = new AtomicInteger(0);
4847          final CFException ex = new CFException();
4848          final CompletableFuture<Integer> f = new CompletableFuture<>();
4849          final DelegatedCompletionStage<Integer> d =
# Line 4795 | Line 4851 | public class CompletableFutureTest exten
4851          if (!createIncomplete) f.completeExceptionally(ex);
4852          final CompletionStage<Integer> g = d.exceptionallyAsync
4853              ((Throwable t) -> {
4854 <                threadAssertSame(t, ex);
4855 <                a.getAndIncrement();
4854 >                assertSame(t, ex);
4855 >                ran.getAndIncrement();
4856                  return v1;
4857              });
4858          if (createIncomplete) f.completeExceptionally(ex);
4859  
4860          checkCompletedNormally(g.toCompletableFuture(), v1);
4861 <        assertEquals(1, a.get());
4861 >        checkCompletedExceptionally(f, ex);
4862 >        assertEquals(1, ran.get());
4863      }}
4864  
4865      /**
# Line 4810 | Line 4867 | public class CompletableFutureTest exten
4867       * throws an exception, it completes exceptionally with that
4868       * exception
4869       */
4870 <    public void testDefaulExceptionallyAsync_exceptionalCompletionActionFailed() {
4870 >    public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4871          for (boolean createIncomplete : new boolean[] { true, false })
4872      {
4873 <        final AtomicInteger a = new AtomicInteger(0);
4873 >        final AtomicInteger ran = new AtomicInteger(0);
4874          final CFException ex1 = new CFException();
4875          final CFException ex2 = new CFException();
4876          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4822 | Line 4879 | public class CompletableFutureTest exten
4879          if (!createIncomplete) f.completeExceptionally(ex1);
4880          final CompletionStage<Integer> g = d.exceptionallyAsync
4881              ((Throwable t) -> {
4882 <                threadAssertSame(t, ex1);
4883 <                a.getAndIncrement();
4882 >                assertSame(t, ex1);
4883 >                ran.getAndIncrement();
4884                  throw ex2;
4885              });
4886          if (createIncomplete) f.completeExceptionally(ex1);
# Line 4831 | Line 4888 | public class CompletableFutureTest exten
4888          checkCompletedWithWrappedException(g.toCompletableFuture(), ex2);
4889          checkCompletedExceptionally(f, ex1);
4890          checkCompletedExceptionally(d.toCompletableFuture(), ex1);
4891 <        assertEquals(1, a.get());
4891 >        assertEquals(1, ran.get());
4892      }}
4893  
4894      /**
4895 <     * default exceptionallyCompose result completes normally after normal
4896 <     * completion of source
4895 >     * default-implemented exceptionallyCompose result completes
4896 >     * normally after normal completion of source
4897       */
4898      public void testDefaultExceptionallyCompose_normalCompletion() {
4899          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4884 | Line 4941 | public class CompletableFutureTest exten
4941       */
4942      public void testDefaultExceptionallyCompose_actionFailed() {
4943          for (boolean createIncomplete : new boolean[] { true, false })
4887 –        for (Integer v1 : new Integer[] { 1, null })
4944      {
4945          final CFException ex = new CFException();
4946          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4902 | Line 4958 | public class CompletableFutureTest exten
4958      }}
4959  
4960      /**
4961 <     * default exceptionallyComposeAsync result completes normally after normal
4962 <     * completion of source
4961 >     * default-implemented exceptionallyComposeAsync result completes
4962 >     * normally after normal completion of source
4963       */
4964      public void testDefaultExceptionallyComposeAsync_normalCompletion() {
4965          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4951 | Line 5007 | public class CompletableFutureTest exten
5007       */
5008      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5009          for (boolean createIncomplete : new boolean[] { true, false })
4954 –        for (Integer v1 : new Integer[] { 1, null })
5010      {
5011          final CFException ex = new CFException();
5012          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4968 | Line 5023 | public class CompletableFutureTest exten
5023          r.assertInvoked();
5024      }}
5025  
4971 –
5026      /**
5027 <     * default exceptionallyComposeAsync result completes normally after normal
5028 <     * completion of source
5027 >     * default-implemented exceptionallyComposeAsync result completes
5028 >     * normally after normal completion of source
5029       */
5030      public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
5031          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4983 | Line 5037 | public class CompletableFutureTest exten
5037          final DelegatedCompletionStage<Integer> d =
5038              new DelegatedCompletionStage<Integer>(f);
5039          if (!createIncomplete) assertTrue(f.complete(v1));
5040 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5040 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5041          if (createIncomplete) assertTrue(f.complete(v1));
5042  
5043          checkCompletedNormally(f, v1);
# Line 5005 | Line 5059 | public class CompletableFutureTest exten
5059          final DelegatedCompletionStage<Integer> d =
5060              new DelegatedCompletionStage<Integer>(f);
5061          if (!createIncomplete) f.completeExceptionally(ex);
5062 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5062 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5063          if (createIncomplete) f.completeExceptionally(ex);
5064  
5065          checkCompletedExceptionally(f, ex);
# Line 5019 | Line 5073 | public class CompletableFutureTest exten
5073       */
5074      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5075          for (boolean createIncomplete : new boolean[] { true, false })
5022 –        for (Integer v1 : new Integer[] { 1, null })
5076      {
5077          final CFException ex = new CFException();
5078          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 5028 | Line 5081 | public class CompletableFutureTest exten
5081          final DelegatedCompletionStage<Integer> d =
5082              new DelegatedCompletionStage<Integer>(f);
5083          if (!createIncomplete) f.completeExceptionally(ex);
5084 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5084 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5085          if (createIncomplete) f.completeExceptionally(ex);
5086  
5087          checkCompletedExceptionally(f, ex);

Diff Legend

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