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.199 by dl, Thu Sep 20 00:01:22 2018 UTC vs.
Revision 1.219 by jsr166, Sat Nov 24 18:33:26 2018 UTC

# Line 551 | Line 551 | public class CompletableFutureTest exten
551          public CompletableFuture<Integer> apply(Integer x) {
552              invoked();
553              value = x;
554 <            CompletableFuture<Integer> f = new CompletableFuture<>();
555 <            assertTrue(f.complete(inc(x)));
556 <            return f;
554 >            return CompletableFuture.completedFuture(inc(x));
555          }
556      }
557  
# Line 574 | Line 572 | public class CompletableFutureTest exten
572          ExceptionalCompletableFutureFunction(ExecutionMode m) { super(m); }
573          public CompletionStage<Integer> apply(Throwable x) {
574              invoked();
575 <            CompletableFuture<Integer> d = new CompletableFuture<Integer>();
578 <            d.complete(value);
579 <            return d;
575 >            return CompletableFuture.completedFuture(value);
576          }
577      }
578  
# Line 930 | 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");
940 <                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 955 | 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 980 | 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 988 | 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 1008 | 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 1034 | 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 1042 | 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 1062 | 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 1089 | 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 1097 | 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 1118 | 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 1128 | 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 1141 | 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 1154 | 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 1182 | 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 1212 | 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 1240 | 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 1268 | 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 1278 | 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 3123 | 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 3206 | 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 })
3209 –        for (Integer v1 : new Integer[] { 1, null })
3204      {
3205          final CFException ex = new CFException();
3206          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3221 | 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 3601 | Line 3647 | public class CompletableFutureTest exten
3647          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3648          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3649  
3604 –        List<CompletableFuture<?>> futures = new ArrayList<>();
3605 –
3606 –        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3607 –        srcs.add(complete);
3608 –        srcs.add(incomplete);
3609 –
3650          List<CompletableFuture<?>> fs = new ArrayList<>();
3651          fs.add(incomplete.thenRunAsync(() -> {}, e));
3652          fs.add(incomplete.thenAcceptAsync(z -> {}, e));
# Line 4784 | Line 4824 | public class CompletableFutureTest exten
4824      }
4825  
4826      /**
4827 +     * default-implemented exceptionallyAsync action is not invoked when
4828 +     * source completes normally, and source result is propagated
4829 +     */
4830 +    public void testDefaultExceptionallyAsync_normalCompletion() {
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 +                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 +    /**
4852       * default-implemented exceptionallyAsync action completes with
4853       * function value on source exception
4854       */
4855 <    public void testDefaulExceptionallyAsync_exceptionalCompletion() {
4855 >    public void testDefaultExceptionallyAsync_exceptionalCompletion() {
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 4799 | 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 >        assertEquals(1, ran.get());
4875      }}
4876  
4877      /**
# Line 4814 | Line 4879 | public class CompletableFutureTest exten
4879       * throws an exception, it completes exceptionally with that
4880       * exception
4881       */
4882 <    public void testDefaulExceptionallyAsync_exceptionalCompletionActionFailed() {
4882 >    public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4883          for (boolean createIncomplete : new boolean[] { true, false })
4884      {
4885 <        final AtomicInteger a = new AtomicInteger(0);
4885 >        final AtomicInteger ran = new AtomicInteger(0);
4886          final CFException ex1 = new CFException();
4887          final CFException ex2 = new CFException();
4888          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4826 | Line 4891 | public class CompletableFutureTest exten
4891          if (!createIncomplete) f.completeExceptionally(ex1);
4892          final CompletionStage<Integer> g = d.exceptionallyAsync
4893              ((Throwable t) -> {
4894 <                threadAssertSame(t, ex1);
4895 <                a.getAndIncrement();
4894 >                assertSame(t, ex1);
4895 >                ran.getAndIncrement();
4896                  throw ex2;
4897              });
4898          if (createIncomplete) f.completeExceptionally(ex1);
# Line 4835 | Line 4900 | public class CompletableFutureTest exten
4900          checkCompletedWithWrappedException(g.toCompletableFuture(), ex2);
4901          checkCompletedExceptionally(f, ex1);
4902          checkCompletedExceptionally(d.toCompletableFuture(), ex1);
4903 <        assertEquals(1, a.get());
4903 >        assertEquals(1, ran.get());
4904      }}
4905  
4906      /**
4907 <     * defult exceptionallyCompose result completes normally after normal
4908 <     * completion of source
4907 >     * default-implemented exceptionallyCompose result completes
4908 >     * normally after normal completion of source
4909       */
4910      public void testDefaultExceptionallyCompose_normalCompletion() {
4911          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4888 | Line 4953 | public class CompletableFutureTest exten
4953       */
4954      public void testDefaultExceptionallyCompose_actionFailed() {
4955          for (boolean createIncomplete : new boolean[] { true, false })
4891 –        for (Integer v1 : new Integer[] { 1, null })
4956      {
4957          final CFException ex = new CFException();
4958          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4906 | Line 4970 | public class CompletableFutureTest exten
4970      }}
4971  
4972      /**
4973 <     * defult exceptionallyComposeAsync result completes normally after normal
4974 <     * completion of source
4973 >     * default-implemented exceptionallyComposeAsync result completes
4974 >     * normally after normal completion of source
4975       */
4976      public void testDefaultExceptionallyComposeAsync_normalCompletion() {
4977          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4955 | Line 5019 | public class CompletableFutureTest exten
5019       */
5020      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5021          for (boolean createIncomplete : new boolean[] { true, false })
4958 –        for (Integer v1 : new Integer[] { 1, null })
5022      {
5023          final CFException ex = new CFException();
5024          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4972 | Line 5035 | public class CompletableFutureTest exten
5035          r.assertInvoked();
5036      }}
5037  
4975 –
5038      /**
5039 <     * defult exceptionallyComposeAsync result completes normally after normal
5040 <     * completion of source
5039 >     * default-implemented exceptionallyComposeAsync result completes
5040 >     * normally after normal completion of source
5041       */
5042      public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
5043          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4987 | Line 5049 | public class CompletableFutureTest exten
5049          final DelegatedCompletionStage<Integer> d =
5050              new DelegatedCompletionStage<Integer>(f);
5051          if (!createIncomplete) assertTrue(f.complete(v1));
5052 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5052 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5053          if (createIncomplete) assertTrue(f.complete(v1));
5054  
5055          checkCompletedNormally(f, v1);
# Line 5009 | Line 5071 | public class CompletableFutureTest exten
5071          final DelegatedCompletionStage<Integer> d =
5072              new DelegatedCompletionStage<Integer>(f);
5073          if (!createIncomplete) f.completeExceptionally(ex);
5074 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5074 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5075          if (createIncomplete) f.completeExceptionally(ex);
5076  
5077          checkCompletedExceptionally(f, ex);
# Line 5023 | Line 5085 | public class CompletableFutureTest exten
5085       */
5086      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5087          for (boolean createIncomplete : new boolean[] { true, false })
5026 –        for (Integer v1 : new Integer[] { 1, null })
5088      {
5089          final CFException ex = new CFException();
5090          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 5032 | Line 5093 | public class CompletableFutureTest exten
5093          final DelegatedCompletionStage<Integer> d =
5094              new DelegatedCompletionStage<Integer>(f);
5095          if (!createIncomplete) f.completeExceptionally(ex);
5096 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5096 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5097          if (createIncomplete) f.completeExceptionally(ex);
5098  
5099          checkCompletedExceptionally(f, ex);
# Line 5041 | Line 5102 | public class CompletableFutureTest exten
5102      }}
5103  
5104   }
5044 –

Diff Legend

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