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.201 by jsr166, Sat Sep 22 21:04:48 2018 UTC vs.
Revision 1.218 by jsr166, Sat Nov 24 18:24:14 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      {
933 –        final AtomicInteger a = new AtomicInteger(0);
929          final CompletableFuture<Integer> f = new CompletableFuture<>();
930          if (!createIncomplete) assertTrue(f.complete(v1));
931          final CompletableFuture<Integer> g = m.exceptionally
932              (f, (Throwable t) -> {
938 –                a.getAndIncrement();
933                  threadFail("should not be called");
934                  return null;            // unreached
935              });
# Line 943 | Line 937 | public class CompletableFutureTest exten
937  
938          checkCompletedNormally(g, v1);
939          checkCompletedNormally(f, v1);
946 –        assertEquals(0, a.get());
940      }}
941  
942      /**
# Line 955 | Line 948 | public class CompletableFutureTest exten
948          for (boolean createIncomplete : new boolean[] { true, false })
949          for (Integer v1 : new Integer[] { 1, null })
950      {
951 <        final AtomicInteger a = new AtomicInteger(0);
951 >        final AtomicInteger ran = new AtomicInteger(0);
952          final CFException ex = new CFException();
953          final CompletableFuture<Integer> f = new CompletableFuture<>();
954          if (!createIncomplete) f.completeExceptionally(ex);
955          final CompletableFuture<Integer> g = m.exceptionally
956              (f, (Throwable t) -> {
957                  m.checkExecutionMode();
958 <                threadAssertSame(t, ex);
959 <                a.getAndIncrement();
958 >                assertSame(t, ex);
959 >                ran.getAndIncrement();
960                  return v1;
961              });
962          if (createIncomplete) f.completeExceptionally(ex);
963  
964          checkCompletedNormally(g, v1);
965 <        assertEquals(1, a.get());
965 >        assertEquals(1, ran.get());
966      }}
967  
968      /**
# Line 980 | Line 973 | public class CompletableFutureTest exten
973          for (ExecutionMode m : ExecutionMode.values())
974          for (boolean createIncomplete : new boolean[] { true, false })
975      {
976 <        final AtomicInteger a = new AtomicInteger(0);
976 >        final AtomicInteger ran = new AtomicInteger(0);
977          final CFException ex1 = new CFException();
978          final CFException ex2 = new CFException();
979          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 988 | Line 981 | public class CompletableFutureTest exten
981          final CompletableFuture<Integer> g = m.exceptionally
982              (f, (Throwable t) -> {
983                  m.checkExecutionMode();
984 <                threadAssertSame(t, ex1);
985 <                a.getAndIncrement();
984 >                assertSame(t, ex1);
985 >                ran.getAndIncrement();
986                  throw ex2;
987              });
988          if (createIncomplete) f.completeExceptionally(ex1);
989  
990          checkCompletedWithWrappedException(g, ex2);
991          checkCompletedExceptionally(f, ex1);
992 <        assertEquals(1, a.get());
992 >        assertEquals(1, ran.get());
993      }}
994  
995      /**
# Line 1008 | Line 1001 | public class CompletableFutureTest exten
1001          for (boolean createIncomplete : new boolean[] { true, false })
1002          for (Integer v1 : new Integer[] { 1, null })
1003      {
1004 <        final AtomicInteger a = new AtomicInteger(0);
1004 >        final AtomicInteger ran = new AtomicInteger(0);
1005          final CompletableFuture<Integer> f = new CompletableFuture<>();
1006          if (!createIncomplete) assertTrue(f.complete(v1));
1007          final CompletableFuture<Integer> g = m.whenComplete
1008              (f,
1009               (Integer result, Throwable t) -> {
1010                  m.checkExecutionMode();
1011 <                threadAssertSame(result, v1);
1012 <                threadAssertNull(t);
1013 <                a.getAndIncrement();
1011 >                assertSame(result, v1);
1012 >                assertNull(t);
1013 >                ran.getAndIncrement();
1014              });
1015          if (createIncomplete) assertTrue(f.complete(v1));
1016  
1017          checkCompletedNormally(g, v1);
1018          checkCompletedNormally(f, v1);
1019 <        assertEquals(1, a.get());
1019 >        assertEquals(1, ran.get());
1020      }}
1021  
1022      /**
# Line 1034 | Line 1027 | public class CompletableFutureTest exten
1027          for (ExecutionMode m : ExecutionMode.values())
1028          for (boolean createIncomplete : new boolean[] { true, false })
1029      {
1030 <        final AtomicInteger a = new AtomicInteger(0);
1030 >        final AtomicInteger ran = new AtomicInteger(0);
1031          final CFException ex = new CFException();
1032          final CompletableFuture<Integer> f = new CompletableFuture<>();
1033          if (!createIncomplete) f.completeExceptionally(ex);
# Line 1042 | Line 1035 | public class CompletableFutureTest exten
1035              (f,
1036               (Integer result, Throwable t) -> {
1037                  m.checkExecutionMode();
1038 <                threadAssertNull(result);
1039 <                threadAssertSame(t, ex);
1040 <                a.getAndIncrement();
1038 >                assertNull(result);
1039 >                assertSame(t, ex);
1040 >                ran.getAndIncrement();
1041              });
1042          if (createIncomplete) f.completeExceptionally(ex);
1043  
1044          checkCompletedWithWrappedException(g, ex);
1045          checkCompletedExceptionally(f, ex);
1046 <        assertEquals(1, a.get());
1046 >        assertEquals(1, ran.get());
1047      }}
1048  
1049      /**
# Line 1062 | Line 1055 | public class CompletableFutureTest exten
1055          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1056          for (boolean createIncomplete : new boolean[] { true, false })
1057      {
1058 <        final AtomicInteger a = new AtomicInteger(0);
1058 >        final AtomicInteger ran = new AtomicInteger(0);
1059          final CompletableFuture<Integer> f = new CompletableFuture<>();
1060          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1061          final CompletableFuture<Integer> g = m.whenComplete
1062              (f,
1063               (Integer result, Throwable t) -> {
1064                  m.checkExecutionMode();
1065 <                threadAssertNull(result);
1066 <                threadAssertTrue(t instanceof CancellationException);
1067 <                a.getAndIncrement();
1065 >                assertNull(result);
1066 >                assertTrue(t instanceof CancellationException);
1067 >                ran.getAndIncrement();
1068              });
1069          if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1070  
1071          checkCompletedWithWrappedCancellationException(g);
1072          checkCancelled(f);
1073 <        assertEquals(1, a.get());
1073 >        assertEquals(1, ran.get());
1074      }}
1075  
1076      /**
# Line 1089 | Line 1082 | public class CompletableFutureTest exten
1082          for (ExecutionMode m : ExecutionMode.values())
1083          for (Integer v1 : new Integer[] { 1, null })
1084      {
1085 <        final AtomicInteger a = new AtomicInteger(0);
1085 >        final AtomicInteger ran = new AtomicInteger(0);
1086          final CFException ex = new CFException();
1087          final CompletableFuture<Integer> f = new CompletableFuture<>();
1088          if (!createIncomplete) assertTrue(f.complete(v1));
# Line 1097 | Line 1090 | public class CompletableFutureTest exten
1090              (f,
1091               (Integer result, Throwable t) -> {
1092                  m.checkExecutionMode();
1093 <                threadAssertSame(result, v1);
1094 <                threadAssertNull(t);
1095 <                a.getAndIncrement();
1093 >                assertSame(result, v1);
1094 >                assertNull(t);
1095 >                ran.getAndIncrement();
1096                  throw ex;
1097              });
1098          if (createIncomplete) assertTrue(f.complete(v1));
1099  
1100          checkCompletedWithWrappedException(g, ex);
1101          checkCompletedNormally(f, v1);
1102 <        assertEquals(1, a.get());
1102 >        assertEquals(1, ran.get());
1103      }}
1104  
1105      /**
# Line 1118 | Line 1111 | public class CompletableFutureTest exten
1111          for (boolean createIncomplete : new boolean[] { true, false })
1112          for (ExecutionMode m : ExecutionMode.values())
1113      {
1114 <        final AtomicInteger a = new AtomicInteger(0);
1114 >        final AtomicInteger ran = new AtomicInteger(0);
1115          final CFException ex1 = new CFException();
1116          final CFException ex2 = new CFException();
1117          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 1128 | Line 1121 | public class CompletableFutureTest exten
1121              (f,
1122               (Integer result, Throwable t) -> {
1123                  m.checkExecutionMode();
1124 <                threadAssertSame(t, ex1);
1125 <                threadAssertNull(result);
1126 <                a.getAndIncrement();
1124 >                assertSame(t, ex1);
1125 >                assertNull(result);
1126 >                ran.getAndIncrement();
1127                  throw ex2;
1128              });
1129          if (createIncomplete) f.completeExceptionally(ex1);
# Line 1141 | Line 1134 | public class CompletableFutureTest exten
1134              assertEquals(1, ex1.getSuppressed().length);
1135              assertSame(ex2, ex1.getSuppressed()[0]);
1136          }
1137 <        assertEquals(1, a.get());
1137 >        assertEquals(1, ran.get());
1138      }}
1139  
1140      /**
# Line 1154 | Line 1147 | public class CompletableFutureTest exten
1147          for (Integer v1 : new Integer[] { 1, null })
1148      {
1149          final CompletableFuture<Integer> f = new CompletableFuture<>();
1150 <        final AtomicInteger a = new AtomicInteger(0);
1150 >        final AtomicInteger ran = new AtomicInteger(0);
1151          if (!createIncomplete) assertTrue(f.complete(v1));
1152          final CompletableFuture<Integer> g = m.handle
1153              (f,
1154               (Integer result, Throwable t) -> {
1155                  m.checkExecutionMode();
1156 <                threadAssertSame(result, v1);
1157 <                threadAssertNull(t);
1158 <                a.getAndIncrement();
1156 >                assertSame(result, v1);
1157 >                assertNull(t);
1158 >                ran.getAndIncrement();
1159                  return inc(v1);
1160              });
1161          if (createIncomplete) assertTrue(f.complete(v1));
1162  
1163          checkCompletedNormally(g, inc(v1));
1164          checkCompletedNormally(f, v1);
1165 <        assertEquals(1, a.get());
1165 >        assertEquals(1, ran.get());
1166      }}
1167  
1168      /**
# Line 1182 | Line 1175 | public class CompletableFutureTest exten
1175          for (Integer v1 : new Integer[] { 1, null })
1176      {
1177          final CompletableFuture<Integer> f = new CompletableFuture<>();
1178 <        final AtomicInteger a = new AtomicInteger(0);
1178 >        final AtomicInteger ran = new AtomicInteger(0);
1179          final CFException ex = new CFException();
1180          if (!createIncomplete) f.completeExceptionally(ex);
1181          final CompletableFuture<Integer> g = m.handle
1182              (f,
1183               (Integer result, Throwable t) -> {
1184                  m.checkExecutionMode();
1185 <                threadAssertNull(result);
1186 <                threadAssertSame(t, ex);
1187 <                a.getAndIncrement();
1185 >                assertNull(result);
1186 >                assertSame(t, ex);
1187 >                ran.getAndIncrement();
1188                  return v1;
1189              });
1190          if (createIncomplete) f.completeExceptionally(ex);
1191  
1192          checkCompletedNormally(g, v1);
1193          checkCompletedExceptionally(f, ex);
1194 <        assertEquals(1, a.get());
1194 >        assertEquals(1, ran.get());
1195      }}
1196  
1197      /**
# Line 1212 | Line 1205 | public class CompletableFutureTest exten
1205          for (Integer v1 : new Integer[] { 1, null })
1206      {
1207          final CompletableFuture<Integer> f = new CompletableFuture<>();
1208 <        final AtomicInteger a = new AtomicInteger(0);
1208 >        final AtomicInteger ran = new AtomicInteger(0);
1209          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1210          final CompletableFuture<Integer> g = m.handle
1211              (f,
1212               (Integer result, Throwable t) -> {
1213                  m.checkExecutionMode();
1214 <                threadAssertNull(result);
1215 <                threadAssertTrue(t instanceof CancellationException);
1216 <                a.getAndIncrement();
1214 >                assertNull(result);
1215 >                assertTrue(t instanceof CancellationException);
1216 >                ran.getAndIncrement();
1217                  return v1;
1218              });
1219          if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1220  
1221          checkCompletedNormally(g, v1);
1222          checkCancelled(f);
1223 <        assertEquals(1, a.get());
1223 >        assertEquals(1, ran.get());
1224      }}
1225  
1226      /**
# Line 1240 | Line 1233 | public class CompletableFutureTest exten
1233          for (Integer v1 : new Integer[] { 1, null })
1234      {
1235          final CompletableFuture<Integer> f = new CompletableFuture<>();
1236 <        final AtomicInteger a = new AtomicInteger(0);
1236 >        final AtomicInteger ran = new AtomicInteger(0);
1237          final CFException ex = new CFException();
1238          if (!createIncomplete) assertTrue(f.complete(v1));
1239          final CompletableFuture<Integer> g = m.handle
1240              (f,
1241               (Integer result, Throwable t) -> {
1242                  m.checkExecutionMode();
1243 <                threadAssertSame(result, v1);
1244 <                threadAssertNull(t);
1245 <                a.getAndIncrement();
1243 >                assertSame(result, v1);
1244 >                assertNull(t);
1245 >                ran.getAndIncrement();
1246                  throw ex;
1247              });
1248          if (createIncomplete) assertTrue(f.complete(v1));
1249  
1250          checkCompletedWithWrappedException(g, ex);
1251          checkCompletedNormally(f, v1);
1252 <        assertEquals(1, a.get());
1252 >        assertEquals(1, ran.get());
1253      }}
1254  
1255      /**
# Line 1268 | Line 1261 | public class CompletableFutureTest exten
1261          for (boolean createIncomplete : new boolean[] { true, false })
1262          for (ExecutionMode m : ExecutionMode.values())
1263      {
1264 <        final AtomicInteger a = new AtomicInteger(0);
1264 >        final AtomicInteger ran = new AtomicInteger(0);
1265          final CFException ex1 = new CFException();
1266          final CFException ex2 = new CFException();
1267          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 1278 | Line 1271 | public class CompletableFutureTest exten
1271              (f,
1272               (Integer result, Throwable t) -> {
1273                  m.checkExecutionMode();
1274 <                threadAssertNull(result);
1275 <                threadAssertSame(ex1, t);
1276 <                a.getAndIncrement();
1274 >                assertNull(result);
1275 >                assertSame(ex1, t);
1276 >                ran.getAndIncrement();
1277                  throw ex2;
1278              });
1279          if (createIncomplete) f.completeExceptionally(ex1);
1280  
1281          checkCompletedWithWrappedException(g, ex2);
1282          checkCompletedExceptionally(f, ex1);
1283 <        assertEquals(1, a.get());
1283 >        assertEquals(1, ran.get());
1284      }}
1285  
1286      /**
# Line 3123 | Line 3116 | public class CompletableFutureTest exten
3116          case 0:
3117              assertTrue(f.complete(v1));
3118              assertTrue(g.completeExceptionally(ex));
3119 <            h = m.thenCompose(f, (x -> g));
3119 >            h = m.thenCompose(f, x -> g);
3120              break;
3121          case 1:
3122              assertTrue(f.complete(v1));
3123 <            h = m.thenCompose(f, (x -> g));
3123 >            h = m.thenCompose(f, x -> g);
3124              assertTrue(g.completeExceptionally(ex));
3125              break;
3126          case 2:
3127              assertTrue(g.completeExceptionally(ex));
3128              assertTrue(f.complete(v1));
3129 <            h = m.thenCompose(f, (x -> g));
3129 >            h = m.thenCompose(f, x -> g);
3130              break;
3131          case 3:
3132              assertTrue(g.completeExceptionally(ex));
3133 <            h = m.thenCompose(f, (x -> g));
3133 >            h = m.thenCompose(f, x -> g);
3134              assertTrue(f.complete(v1));
3135              break;
3136          case 4:
3137 <            h = m.thenCompose(f, (x -> g));
3137 >            h = m.thenCompose(f, x -> g);
3138              assertTrue(f.complete(v1));
3139              assertTrue(g.completeExceptionally(ex));
3140              break;
3141          case 5:
3142 <            h = m.thenCompose(f, (x -> g));
3142 >            h = m.thenCompose(f, x -> g);
3143              assertTrue(f.complete(v1));
3144              assertTrue(g.completeExceptionally(ex));
3145              break;
# Line 3206 | Line 3199 | public class CompletableFutureTest exten
3199      public void testExceptionallyCompose_actionFailed() {
3200          for (ExecutionMode m : ExecutionMode.values())
3201          for (boolean createIncomplete : new boolean[] { true, false })
3209 –        for (Integer v1 : new Integer[] { 1, null })
3202      {
3203          final CFException ex = new CFException();
3204          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3221 | Line 3213 | public class CompletableFutureTest exten
3213          r.assertInvoked();
3214      }}
3215  
3216 +    /**
3217 +     * exceptionallyCompose result completes exceptionally if the
3218 +     * result of the action does
3219 +     */
3220 +    public void testExceptionallyCompose_actionReturnsFailingFuture() {
3221 +        for (ExecutionMode m : ExecutionMode.values())
3222 +        for (int order = 0; order < 6; order++)
3223 +    {
3224 +        final CFException ex0 = new CFException();
3225 +        final CFException ex = new CFException();
3226 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
3227 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
3228 +        final CompletableFuture<Integer> h;
3229 +        // Test all permutations of orders
3230 +        switch (order) {
3231 +        case 0:
3232 +            assertTrue(f.completeExceptionally(ex0));
3233 +            assertTrue(g.completeExceptionally(ex));
3234 +            h = m.exceptionallyCompose(f, x -> g);
3235 +            break;
3236 +        case 1:
3237 +            assertTrue(f.completeExceptionally(ex0));
3238 +            h = m.exceptionallyCompose(f, x -> g);
3239 +            assertTrue(g.completeExceptionally(ex));
3240 +            break;
3241 +        case 2:
3242 +            assertTrue(g.completeExceptionally(ex));
3243 +            assertTrue(f.completeExceptionally(ex0));
3244 +            h = m.exceptionallyCompose(f, x -> g);
3245 +            break;
3246 +        case 3:
3247 +            assertTrue(g.completeExceptionally(ex));
3248 +            h = m.exceptionallyCompose(f, x -> g);
3249 +            assertTrue(f.completeExceptionally(ex0));
3250 +            break;
3251 +        case 4:
3252 +            h = m.exceptionallyCompose(f, x -> g);
3253 +            assertTrue(f.completeExceptionally(ex0));
3254 +            assertTrue(g.completeExceptionally(ex));
3255 +            break;
3256 +        case 5:
3257 +            h = m.exceptionallyCompose(f, x -> g);
3258 +            assertTrue(f.completeExceptionally(ex0));
3259 +            assertTrue(g.completeExceptionally(ex));
3260 +            break;
3261 +        default: throw new AssertionError();
3262 +        }
3263 +
3264 +        checkCompletedExceptionally(g, ex);
3265 +        checkCompletedWithWrappedException(h, ex);
3266 +        checkCompletedExceptionally(f, ex0);
3267 +    }}
3268  
3269      // other static methods
3270  
# Line 3601 | Line 3645 | public class CompletableFutureTest exten
3645          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3646          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3647  
3604 –        List<CompletableFuture<?>> futures = new ArrayList<>();
3605 –
3606 –        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3607 –        srcs.add(complete);
3608 –        srcs.add(incomplete);
3609 –
3648          List<CompletableFuture<?>> fs = new ArrayList<>();
3649          fs.add(incomplete.thenRunAsync(() -> {}, e));
3650          fs.add(incomplete.thenAcceptAsync(z -> {}, e));
# Line 4784 | Line 4822 | public class CompletableFutureTest exten
4822      }
4823  
4824      /**
4825 +     * default-implemented exceptionallyAsync action is not invoked when
4826 +     * source completes normally, and source result is propagated
4827 +     */
4828 +    public void testDefaultExceptionallyAsync_normalCompletion() {
4829 +        for (boolean createIncomplete : new boolean[] { true, false })
4830 +        for (Integer v1 : new Integer[] { 1, null })
4831 +    {
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
4840 +            });
4841 +        if (createIncomplete) assertTrue(f.complete(v1));
4842 +
4843 +        checkCompletedNormally(g.toCompletableFuture(), v1);
4844 +    }}
4845 +
4846 +    /**
4847       * default-implemented exceptionallyAsync action completes with
4848       * function value on source exception
4849       */
4850 <    public void testDefaulExceptionallyAsync_exceptionalCompletion() {
4850 >    public void testDefaultExceptionallyAsync_exceptionalCompletion() {
4851          for (boolean createIncomplete : new boolean[] { true, false })
4852          for (Integer v1 : new Integer[] { 1, null })
4853      {
4854 <        final AtomicInteger a = new AtomicInteger(0);
4854 >        final AtomicInteger ran = new AtomicInteger(0);
4855          final CFException ex = new CFException();
4856          final CompletableFuture<Integer> f = new CompletableFuture<>();
4857          final DelegatedCompletionStage<Integer> d =
# Line 4799 | Line 4859 | public class CompletableFutureTest exten
4859          if (!createIncomplete) f.completeExceptionally(ex);
4860          final CompletionStage<Integer> g = d.exceptionallyAsync
4861              ((Throwable t) -> {
4862 <                threadAssertSame(t, ex);
4863 <                a.getAndIncrement();
4862 >                assertSame(t, ex);
4863 >                ran.getAndIncrement();
4864                  return v1;
4865              });
4866          if (createIncomplete) f.completeExceptionally(ex);
4867  
4868          checkCompletedNormally(g.toCompletableFuture(), v1);
4869 <        assertEquals(1, a.get());
4869 >        assertEquals(1, ran.get());
4870      }}
4871  
4872      /**
# Line 4814 | Line 4874 | public class CompletableFutureTest exten
4874       * throws an exception, it completes exceptionally with that
4875       * exception
4876       */
4877 <    public void testDefaulExceptionallyAsync_exceptionalCompletionActionFailed() {
4877 >    public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4878          for (boolean createIncomplete : new boolean[] { true, false })
4879      {
4880 <        final AtomicInteger a = new AtomicInteger(0);
4880 >        final AtomicInteger ran = new AtomicInteger(0);
4881          final CFException ex1 = new CFException();
4882          final CFException ex2 = new CFException();
4883          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4826 | Line 4886 | public class CompletableFutureTest exten
4886          if (!createIncomplete) f.completeExceptionally(ex1);
4887          final CompletionStage<Integer> g = d.exceptionallyAsync
4888              ((Throwable t) -> {
4889 <                threadAssertSame(t, ex1);
4890 <                a.getAndIncrement();
4889 >                assertSame(t, ex1);
4890 >                ran.getAndIncrement();
4891                  throw ex2;
4892              });
4893          if (createIncomplete) f.completeExceptionally(ex1);
# Line 4835 | Line 4895 | public class CompletableFutureTest exten
4895          checkCompletedWithWrappedException(g.toCompletableFuture(), ex2);
4896          checkCompletedExceptionally(f, ex1);
4897          checkCompletedExceptionally(d.toCompletableFuture(), ex1);
4898 <        assertEquals(1, a.get());
4898 >        assertEquals(1, ran.get());
4899      }}
4900  
4901      /**
4902 <     * default exceptionallyCompose result completes normally after normal
4903 <     * completion of source
4902 >     * default-implemented exceptionallyCompose result completes
4903 >     * normally after normal completion of source
4904       */
4905      public void testDefaultExceptionallyCompose_normalCompletion() {
4906          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4888 | Line 4948 | public class CompletableFutureTest exten
4948       */
4949      public void testDefaultExceptionallyCompose_actionFailed() {
4950          for (boolean createIncomplete : new boolean[] { true, false })
4891 –        for (Integer v1 : new Integer[] { 1, null })
4951      {
4952          final CFException ex = new CFException();
4953          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4906 | Line 4965 | public class CompletableFutureTest exten
4965      }}
4966  
4967      /**
4968 <     * default exceptionallyComposeAsync result completes normally after normal
4969 <     * completion of source
4968 >     * default-implemented exceptionallyComposeAsync result completes
4969 >     * normally after normal completion of source
4970       */
4971      public void testDefaultExceptionallyComposeAsync_normalCompletion() {
4972          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4955 | Line 5014 | public class CompletableFutureTest exten
5014       */
5015      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5016          for (boolean createIncomplete : new boolean[] { true, false })
4958 –        for (Integer v1 : new Integer[] { 1, null })
5017      {
5018          final CFException ex = new CFException();
5019          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4972 | Line 5030 | public class CompletableFutureTest exten
5030          r.assertInvoked();
5031      }}
5032  
4975 –
5033      /**
5034 <     * default exceptionallyComposeAsync result completes normally after normal
5035 <     * completion of source
5034 >     * default-implemented exceptionallyComposeAsync result completes
5035 >     * normally after normal completion of source
5036       */
5037      public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
5038          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4987 | Line 5044 | public class CompletableFutureTest exten
5044          final DelegatedCompletionStage<Integer> d =
5045              new DelegatedCompletionStage<Integer>(f);
5046          if (!createIncomplete) assertTrue(f.complete(v1));
5047 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5047 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5048          if (createIncomplete) assertTrue(f.complete(v1));
5049  
5050          checkCompletedNormally(f, v1);
# Line 5009 | Line 5066 | public class CompletableFutureTest exten
5066          final DelegatedCompletionStage<Integer> d =
5067              new DelegatedCompletionStage<Integer>(f);
5068          if (!createIncomplete) f.completeExceptionally(ex);
5069 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5069 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5070          if (createIncomplete) f.completeExceptionally(ex);
5071  
5072          checkCompletedExceptionally(f, ex);
# Line 5023 | Line 5080 | public class CompletableFutureTest exten
5080       */
5081      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5082          for (boolean createIncomplete : new boolean[] { true, false })
5026 –        for (Integer v1 : new Integer[] { 1, null })
5083      {
5084          final CFException ex = new CFException();
5085          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 5032 | Line 5088 | public class CompletableFutureTest exten
5088          final DelegatedCompletionStage<Integer> d =
5089              new DelegatedCompletionStage<Integer>(f);
5090          if (!createIncomplete) f.completeExceptionally(ex);
5091 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5091 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5092          if (createIncomplete) f.completeExceptionally(ex);
5093  
5094          checkCompletedExceptionally(f, ex);

Diff Legend

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