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.211 by jsr166, Mon Sep 24 14:45:19 2018 UTC vs.
Revision 1.215 by jsr166, Wed Nov 21 23:19:03 2018 UTC

# 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 3199 | 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 })
3202 –        for (Integer v1 : new Integer[] { 1, null })
3202      {
3203          final CFException ex = new CFException();
3204          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3221 | Line 3220 | public class CompletableFutureTest exten
3220      public void testExceptionallyCompose_actionReturnsFailingFuture() {
3221          for (ExecutionMode m : ExecutionMode.values())
3222          for (int order = 0; order < 6; order++)
3224 –        for (Integer v1 : new Integer[] { 1, null })
3223      {
3224          final CFException ex0 = new CFException();
3225          final CFException ex = new CFException();
# Line 3233 | 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 4907 | Line 4905 | public class CompletableFutureTest exten
4905      }}
4906  
4907      /**
4908 <     * default exceptionallyCompose result completes normally after normal
4909 <     * completion of source
4908 >     * default-implemented exceptionallyCompose result completes
4909 >     * normally after normal completion of source
4910       */
4911      public void testDefaultExceptionallyCompose_normalCompletion() {
4912          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4956 | Line 4954 | public class CompletableFutureTest exten
4954       */
4955      public void testDefaultExceptionallyCompose_actionFailed() {
4956          for (boolean createIncomplete : new boolean[] { true, false })
4959 –        for (Integer v1 : new Integer[] { 1, null })
4957      {
4958          final CFException ex = new CFException();
4959          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4974 | Line 4971 | public class CompletableFutureTest exten
4971      }}
4972  
4973      /**
4974 <     * default exceptionallyComposeAsync result completes normally after normal
4975 <     * completion of source
4974 >     * default-implemented exceptionallyComposeAsync result completes
4975 >     * normally after normal completion of source
4976       */
4977      public void testDefaultExceptionallyComposeAsync_normalCompletion() {
4978          for (boolean createIncomplete : new boolean[] { true, false })
# Line 5023 | Line 5020 | public class CompletableFutureTest exten
5020       */
5021      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5022          for (boolean createIncomplete : new boolean[] { true, false })
5026 –        for (Integer v1 : new Integer[] { 1, null })
5023      {
5024          final CFException ex = new CFException();
5025          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 5040 | Line 5036 | public class CompletableFutureTest exten
5036          r.assertInvoked();
5037      }}
5038  
5043 –
5039      /**
5040 <     * default exceptionallyComposeAsync result completes normally after normal
5041 <     * completion of source
5040 >     * default-implemented exceptionallyComposeAsync result completes
5041 >     * normally after normal completion of source
5042       */
5043      public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
5044          for (boolean createIncomplete : new boolean[] { true, false })
# Line 5091 | Line 5086 | public class CompletableFutureTest exten
5086       */
5087      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5088          for (boolean createIncomplete : new boolean[] { true, false })
5094 –        for (Integer v1 : new Integer[] { 1, null })
5089      {
5090          final CFException ex = new CFException();
5091          final CompletableFuture<Integer> f = new CompletableFuture<>();

Diff Legend

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