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.209 by jsr166, Sun Sep 23 17:02:24 2018 UTC vs.
Revision 1.217 by jsr166, Sat Nov 24 18:13:28 2018 UTC

# Line 955 | Line 955 | public class CompletableFutureTest exten
955          final CompletableFuture<Integer> g = m.exceptionally
956              (f, (Throwable t) -> {
957                  m.checkExecutionMode();
958 <                threadAssertSame(t, ex);
958 >                assertSame(t, ex);
959                  a.getAndIncrement();
960                  return v1;
961              });
# Line 981 | Line 981 | public class CompletableFutureTest exten
981          final CompletableFuture<Integer> g = m.exceptionally
982              (f, (Throwable t) -> {
983                  m.checkExecutionMode();
984 <                threadAssertSame(t, ex1);
984 >                assertSame(t, ex1);
985                  a.getAndIncrement();
986                  throw ex2;
987              });
# Line 1008 | Line 1008 | public class CompletableFutureTest exten
1008              (f,
1009               (Integer result, Throwable t) -> {
1010                  m.checkExecutionMode();
1011 <                threadAssertSame(result, v1);
1012 <                threadAssertNull(t);
1011 >                assertSame(result, v1);
1012 >                assertNull(t);
1013                  a.getAndIncrement();
1014              });
1015          if (createIncomplete) assertTrue(f.complete(v1));
# Line 1035 | Line 1035 | public class CompletableFutureTest exten
1035              (f,
1036               (Integer result, Throwable t) -> {
1037                  m.checkExecutionMode();
1038 <                threadAssertNull(result);
1039 <                threadAssertSame(t, ex);
1038 >                assertNull(result);
1039 >                assertSame(t, ex);
1040                  a.getAndIncrement();
1041              });
1042          if (createIncomplete) f.completeExceptionally(ex);
# Line 1062 | Line 1062 | public class CompletableFutureTest exten
1062              (f,
1063               (Integer result, Throwable t) -> {
1064                  m.checkExecutionMode();
1065 <                threadAssertNull(result);
1066 <                threadAssertTrue(t instanceof CancellationException);
1065 >                assertNull(result);
1066 >                assertTrue(t instanceof CancellationException);
1067                  a.getAndIncrement();
1068              });
1069          if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1090 | Line 1090 | public class CompletableFutureTest exten
1090              (f,
1091               (Integer result, Throwable t) -> {
1092                  m.checkExecutionMode();
1093 <                threadAssertSame(result, v1);
1094 <                threadAssertNull(t);
1093 >                assertSame(result, v1);
1094 >                assertNull(t);
1095                  a.getAndIncrement();
1096                  throw ex;
1097              });
# Line 1121 | Line 1121 | public class CompletableFutureTest exten
1121              (f,
1122               (Integer result, Throwable t) -> {
1123                  m.checkExecutionMode();
1124 <                threadAssertSame(t, ex1);
1125 <                threadAssertNull(result);
1124 >                assertSame(t, ex1);
1125 >                assertNull(result);
1126                  a.getAndIncrement();
1127                  throw ex2;
1128              });
# Line 1153 | Line 1153 | public class CompletableFutureTest exten
1153              (f,
1154               (Integer result, Throwable t) -> {
1155                  m.checkExecutionMode();
1156 <                threadAssertSame(result, v1);
1157 <                threadAssertNull(t);
1156 >                assertSame(result, v1);
1157 >                assertNull(t);
1158                  a.getAndIncrement();
1159                  return inc(v1);
1160              });
# Line 1182 | Line 1182 | public class CompletableFutureTest exten
1182              (f,
1183               (Integer result, Throwable t) -> {
1184                  m.checkExecutionMode();
1185 <                threadAssertNull(result);
1186 <                threadAssertSame(t, ex);
1185 >                assertNull(result);
1186 >                assertSame(t, ex);
1187                  a.getAndIncrement();
1188                  return v1;
1189              });
# Line 1211 | Line 1211 | public class CompletableFutureTest exten
1211              (f,
1212               (Integer result, Throwable t) -> {
1213                  m.checkExecutionMode();
1214 <                threadAssertNull(result);
1215 <                threadAssertTrue(t instanceof CancellationException);
1214 >                assertNull(result);
1215 >                assertTrue(t instanceof CancellationException);
1216                  a.getAndIncrement();
1217                  return v1;
1218              });
# Line 1240 | Line 1240 | public class CompletableFutureTest exten
1240              (f,
1241               (Integer result, Throwable t) -> {
1242                  m.checkExecutionMode();
1243 <                threadAssertSame(result, v1);
1244 <                threadAssertNull(t);
1243 >                assertSame(result, v1);
1244 >                assertNull(t);
1245                  a.getAndIncrement();
1246                  throw ex;
1247              });
# Line 1271 | Line 1271 | public class CompletableFutureTest exten
1271              (f,
1272               (Integer result, Throwable t) -> {
1273                  m.checkExecutionMode();
1274 <                threadAssertNull(result);
1275 <                threadAssertSame(ex1, t);
1274 >                assertNull(result);
1275 >                assertSame(ex1, t);
1276                  a.getAndIncrement();
1277                  throw ex2;
1278              });
# Line 3116 | 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 3167 | Line 3167 | public class CompletableFutureTest exten
3167          final CompletableFuture<Integer> g = m.exceptionallyCompose(f, r);
3168          if (createIncomplete) assertTrue(f.complete(v1));
3169  
3170 –        if (!createIncomplete && testImplementationDetails)
3171 –            assertSame(f, g);   // an optimization
3172 –
3170          checkCompletedNormally(f, v1);
3171          checkCompletedNormally(g, v1);
3172          r.assertNotInvoked();
# Line 3202 | 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 })
3205 –        for (Integer v1 : new Integer[] { 1, null })
3202      {
3203          final CFException ex = new CFException();
3204          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3218 | Line 3214 | public class CompletableFutureTest exten
3214      }}
3215  
3216      /**
3217 <     * thenComposeExceptionally result completes exceptionally if the
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++)
3227 –        for (Integer v1 : new Integer[] { 1, null })
3223      {
3224          final CFException ex0 = new CFException();
3225          final CFException ex = new CFException();
# Line 3236 | Line 3231 | public class CompletableFutureTest exten
3231          case 0:
3232              assertTrue(f.completeExceptionally(ex0));
3233              assertTrue(g.completeExceptionally(ex));
3234 <            h = m.exceptionallyCompose(f, (x -> g));
3234 >            h = m.exceptionallyCompose(f, x -> g);
3235              break;
3236          case 1:
3237              assertTrue(f.completeExceptionally(ex0));
3238 <            h = m.exceptionallyCompose(f, (x -> g));
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));
3244 >            h = m.exceptionallyCompose(f, x -> g);
3245              break;
3246          case 3:
3247              assertTrue(g.completeExceptionally(ex));
3248 <            h = m.exceptionallyCompose(f, (x -> g));
3248 >            h = m.exceptionallyCompose(f, x -> g);
3249              assertTrue(f.completeExceptionally(ex0));
3250              break;
3251          case 4:
3252 <            h = m.exceptionallyCompose(f, (x -> g));
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));
3257 >            h = m.exceptionallyCompose(f, x -> g);
3258              assertTrue(f.completeExceptionally(ex0));
3259              assertTrue(g.completeExceptionally(ex));
3260              break;
# Line 3267 | Line 3262 | public class CompletableFutureTest exten
3262          }
3263  
3264          checkCompletedExceptionally(g, ex);
3265 <
3271 <        // TODO: should this be: checkCompletedWithWrappedException(h, ex);
3272 <        try {
3273 <            h.join();
3274 <            shouldThrow();
3275 <        } catch (Throwable t) {
3276 <            assertSame(ex, (t instanceof CompletionException) ? t.getCause() : t);
3277 <        }
3278 <
3265 >        checkCompletedWithWrappedException(h, ex);
3266          checkCompletedExceptionally(f, ex0);
3267      }}
3268  
# Line 3658 | Line 3645 | public class CompletableFutureTest exten
3645          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3646          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3647  
3661 –        List<CompletableFuture<?>> futures = new ArrayList<>();
3662 –
3663 –        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3664 –        srcs.add(complete);
3665 –        srcs.add(incomplete);
3666 –
3648          List<CompletableFuture<?>> fs = new ArrayList<>();
3649          fs.add(incomplete.thenRunAsync(() -> {}, e));
3650          fs.add(incomplete.thenAcceptAsync(z -> {}, e));
# Line 4878 | 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);
4862 >                assertSame(t, ex);
4863                  a.getAndIncrement();
4864                  return v1;
4865              });
# Line 4905 | 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);
4889 >                assertSame(t, ex1);
4890                  a.getAndIncrement();
4891                  throw ex2;
4892              });
# Line 4918 | Line 4899 | public class CompletableFutureTest exten
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 4967 | Line 4948 | public class CompletableFutureTest exten
4948       */
4949      public void testDefaultExceptionallyCompose_actionFailed() {
4950          for (boolean createIncomplete : new boolean[] { true, false })
4970 –        for (Integer v1 : new Integer[] { 1, null })
4951      {
4952          final CFException ex = new CFException();
4953          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4985 | 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 5034 | Line 5014 | public class CompletableFutureTest exten
5014       */
5015      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5016          for (boolean createIncomplete : new boolean[] { true, false })
5037 –        for (Integer v1 : new Integer[] { 1, null })
5017      {
5018          final CFException ex = new CFException();
5019          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 5051 | Line 5030 | public class CompletableFutureTest exten
5030          r.assertInvoked();
5031      }}
5032  
5054 –
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 5102 | Line 5080 | public class CompletableFutureTest exten
5080       */
5081      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5082          for (boolean createIncomplete : new boolean[] { true, false })
5105 –        for (Integer v1 : new Integer[] { 1, null })
5083      {
5084          final CFException ex = new CFException();
5085          final CompletableFuture<Integer> f = new CompletableFuture<>();

Diff Legend

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