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.214 by jsr166, Mon Sep 24 18:09:30 2018 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 CompletableFuture<Integer> f = new CompletableFuture<>();
930          if (!createIncomplete) assertTrue(f.complete(v1));
931          final CompletableFuture<Integer> g = m.exceptionally
932              (f, (Throwable t) -> {
934 –                a.getAndIncrement();
933                  threadFail("should not be called");
934                  return null;            // unreached
935              });
# Line 939 | Line 937 | public class CompletableFutureTest exten
937  
938          checkCompletedNormally(g, v1);
939          checkCompletedNormally(f, v1);
942 –        assertEquals(0, a.get());
940      }}
941  
942      /**
# 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 3217 | 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 4780 | Line 4828 | public class CompletableFutureTest exten
4828      }
4829  
4830      /**
4831 +     * default-implemented exceptionallyAsync action is not invoked when
4832 +     * source completes normally, and source result is propagated
4833 +     */
4834 +    public void testDefaultExceptionallyAsync_normalCompletion() {
4835 +        for (boolean createIncomplete : new boolean[] { true, false })
4836 +        for (Integer v1 : new Integer[] { 1, null })
4837 +    {
4838 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
4839 +        final DelegatedCompletionStage<Integer> d =
4840 +            new DelegatedCompletionStage<Integer>(f);
4841 +        if (!createIncomplete) assertTrue(f.complete(v1));
4842 +        final CompletionStage<Integer> g = d.exceptionallyAsync
4843 +            ((Throwable t) -> {
4844 +                threadFail("should not be called");
4845 +                return null;            // unreached
4846 +            });
4847 +        if (createIncomplete) assertTrue(f.complete(v1));
4848 +
4849 +        checkCompletedNormally(g.toCompletableFuture(), v1);
4850 +    }}
4851 +
4852 +    /**
4853       * default-implemented exceptionallyAsync action completes with
4854       * function value on source exception
4855       */
4856 <    public void testDefaulExceptionallyAsync_exceptionalCompletion() {
4856 >    public void testDefaultExceptionallyAsync_exceptionalCompletion() {
4857          for (boolean createIncomplete : new boolean[] { true, false })
4858          for (Integer v1 : new Integer[] { 1, null })
4859      {
# Line 4810 | Line 4880 | public class CompletableFutureTest exten
4880       * throws an exception, it completes exceptionally with that
4881       * exception
4882       */
4883 <    public void testDefaulExceptionallyAsync_exceptionalCompletionActionFailed() {
4883 >    public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4884          for (boolean createIncomplete : new boolean[] { true, false })
4885      {
4886          final AtomicInteger a = new AtomicInteger(0);
# Line 4835 | 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 4884 | Line 4954 | public class CompletableFutureTest exten
4954       */
4955      public void testDefaultExceptionallyCompose_actionFailed() {
4956          for (boolean createIncomplete : new boolean[] { true, false })
4887 –        for (Integer v1 : new Integer[] { 1, null })
4957      {
4958          final CFException ex = new CFException();
4959          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4902 | 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 4951 | Line 5020 | public class CompletableFutureTest exten
5020       */
5021      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5022          for (boolean createIncomplete : new boolean[] { true, false })
4954 –        for (Integer v1 : new Integer[] { 1, null })
5023      {
5024          final CFException ex = new CFException();
5025          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4968 | Line 5036 | public class CompletableFutureTest exten
5036          r.assertInvoked();
5037      }}
5038  
4971 –
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 4983 | Line 5050 | public class CompletableFutureTest exten
5050          final DelegatedCompletionStage<Integer> d =
5051              new DelegatedCompletionStage<Integer>(f);
5052          if (!createIncomplete) assertTrue(f.complete(v1));
5053 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5053 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5054          if (createIncomplete) assertTrue(f.complete(v1));
5055  
5056          checkCompletedNormally(f, v1);
# Line 5005 | Line 5072 | public class CompletableFutureTest exten
5072          final DelegatedCompletionStage<Integer> d =
5073              new DelegatedCompletionStage<Integer>(f);
5074          if (!createIncomplete) f.completeExceptionally(ex);
5075 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5075 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5076          if (createIncomplete) f.completeExceptionally(ex);
5077  
5078          checkCompletedExceptionally(f, ex);
# Line 5019 | Line 5086 | public class CompletableFutureTest exten
5086       */
5087      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5088          for (boolean createIncomplete : new boolean[] { true, false })
5022 –        for (Integer v1 : new Integer[] { 1, null })
5089      {
5090          final CFException ex = new CFException();
5091          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 5028 | Line 5094 | public class CompletableFutureTest exten
5094          final DelegatedCompletionStage<Integer> d =
5095              new DelegatedCompletionStage<Integer>(f);
5096          if (!createIncomplete) f.completeExceptionally(ex);
5097 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5097 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5098          if (createIncomplete) f.completeExceptionally(ex);
5099  
5100          checkCompletedExceptionally(f, ex);

Diff Legend

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