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.133 by jsr166, Sun Nov 15 19:39:25 2015 UTC vs.
Revision 1.136 by jsr166, Sun Nov 15 20:17:11 2015 UTC

# Line 876 | Line 876 | public class CompletableFutureTest exten
876          assertEquals(1, a.get());
877      }}
878  
879 +    /**
880 +     * If an "exceptionally action" throws an exception, it completes
881 +     * exceptionally with that exception
882 +     */
883      public void testExceptionally_exceptionalCompletionActionFailed() {
884          for (boolean createIncomplete : new boolean[] { true, false })
885      {
# Line 894 | Line 898 | public class CompletableFutureTest exten
898          if (createIncomplete) f.completeExceptionally(ex1);
899  
900          checkCompletedWithWrappedException(g, ex2);
901 +        checkCompletedExceptionally(f, ex1);
902          assertEquals(1, a.get());
903      }}
904  
# Line 911 | Line 916 | public class CompletableFutureTest exten
916          if (!createIncomplete) assertTrue(f.complete(v1));
917          final CompletableFuture<Integer> g = m.whenComplete
918              (f,
919 <             (Integer x, Throwable t) -> {
919 >             (Integer result, Throwable t) -> {
920                  m.checkExecutionMode();
921 <                threadAssertSame(x, v1);
921 >                threadAssertSame(result, v1);
922                  threadAssertNull(t);
923                  a.getAndIncrement();
924              });
# Line 938 | Line 943 | public class CompletableFutureTest exten
943          if (!createIncomplete) f.completeExceptionally(ex);
944          final CompletableFuture<Integer> g = m.whenComplete
945              (f,
946 <             (Integer x, Throwable t) -> {
946 >             (Integer result, Throwable t) -> {
947                  m.checkExecutionMode();
948 <                threadAssertNull(x);
948 >                threadAssertNull(result);
949                  threadAssertSame(t, ex);
950                  a.getAndIncrement();
951              });
# Line 965 | Line 970 | public class CompletableFutureTest exten
970          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
971          final CompletableFuture<Integer> g = m.whenComplete
972              (f,
973 <             (Integer x, Throwable t) -> {
973 >             (Integer result, Throwable t) -> {
974                  m.checkExecutionMode();
975 <                threadAssertNull(x);
975 >                threadAssertNull(result);
976                  threadAssertTrue(t instanceof CancellationException);
977                  a.getAndIncrement();
978              });
# Line 993 | Line 998 | public class CompletableFutureTest exten
998          if (!createIncomplete) assertTrue(f.complete(v1));
999          final CompletableFuture<Integer> g = m.whenComplete
1000              (f,
1001 <             (Integer x, Throwable t) -> {
1001 >             (Integer result, Throwable t) -> {
1002                  m.checkExecutionMode();
1003 <                threadAssertSame(x, v1);
1003 >                threadAssertSame(result, v1);
1004                  threadAssertNull(t);
1005                  a.getAndIncrement();
1006                  throw ex;
# Line 1010 | Line 1015 | public class CompletableFutureTest exten
1015      /**
1016       * If a whenComplete action throws an exception when triggered by
1017       * a source completion that also throws an exception, the source
1018 <     * exception takes precedence.
1018 >     * exception takes precedence (unlike handle)
1019       */
1020 <    public void testWhenComplete_actionFailedSourceFailed() {
1020 >    public void testWhenComplete_sourceFailedActionFailed() {
1021          for (boolean createIncomplete : new boolean[] { true, false })
1022          for (ExecutionMode m : ExecutionMode.values())
1023      {
# Line 1024 | Line 1029 | public class CompletableFutureTest exten
1029          if (!createIncomplete) f.completeExceptionally(ex1);
1030          final CompletableFuture<Integer> g = m.whenComplete
1031              (f,
1032 <             (Integer x, Throwable t) -> {
1032 >             (Integer result, Throwable t) -> {
1033                  m.checkExecutionMode();
1034                  threadAssertSame(t, ex1);
1035 <                threadAssertNull(x);
1035 >                threadAssertNull(result);
1036                  a.getAndIncrement();
1037                  throw ex2;
1038              });
# Line 1052 | Line 1057 | public class CompletableFutureTest exten
1057          if (!createIncomplete) assertTrue(f.complete(v1));
1058          final CompletableFuture<Integer> g = m.handle
1059              (f,
1060 <             (Integer x, Throwable t) -> {
1060 >             (Integer result, Throwable t) -> {
1061                  m.checkExecutionMode();
1062 <                threadAssertSame(x, v1);
1062 >                threadAssertSame(result, v1);
1063                  threadAssertNull(t);
1064                  a.getAndIncrement();
1065                  return inc(v1);
# Line 1081 | Line 1086 | public class CompletableFutureTest exten
1086          if (!createIncomplete) f.completeExceptionally(ex);
1087          final CompletableFuture<Integer> g = m.handle
1088              (f,
1089 <             (Integer x, Throwable t) -> {
1089 >             (Integer result, Throwable t) -> {
1090                  m.checkExecutionMode();
1091 <                threadAssertNull(x);
1091 >                threadAssertNull(result);
1092                  threadAssertSame(t, ex);
1093                  a.getAndIncrement();
1094                  return v1;
# Line 1110 | Line 1115 | public class CompletableFutureTest exten
1115          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1116          final CompletableFuture<Integer> g = m.handle
1117              (f,
1118 <             (Integer x, Throwable t) -> {
1118 >             (Integer result, Throwable t) -> {
1119                  m.checkExecutionMode();
1120 <                threadAssertNull(x);
1120 >                threadAssertNull(result);
1121                  threadAssertTrue(t instanceof CancellationException);
1122                  a.getAndIncrement();
1123                  return v1;
# Line 1125 | Line 1130 | public class CompletableFutureTest exten
1130      }}
1131  
1132      /**
1133 <     * handle result completes exceptionally if action does
1133 >     * If a "handle action" throws an exception when triggered by
1134 >     * a normal completion, it completes exceptionally
1135       */
1136 <    public void testHandle_sourceFailedActionFailed() {
1136 >    public void testHandle_sourceCompletedNormallyActionFailed() {
1137          for (ExecutionMode m : ExecutionMode.values())
1138          for (boolean createIncomplete : new boolean[] { true, false })
1139 +        for (Integer v1 : new Integer[] { 1, null })
1140      {
1141          final CompletableFuture<Integer> f = new CompletableFuture<>();
1142          final AtomicInteger a = new AtomicInteger(0);
1143 <        final CFException ex1 = new CFException();
1144 <        final CFException ex2 = new CFException();
1138 <        if (!createIncomplete) f.completeExceptionally(ex1);
1143 >        final CFException ex = new CFException();
1144 >        if (!createIncomplete) assertTrue(f.complete(v1));
1145          final CompletableFuture<Integer> g = m.handle
1146              (f,
1147 <             (Integer x, Throwable t) -> {
1147 >             (Integer result, Throwable t) -> {
1148                  m.checkExecutionMode();
1149 <                threadAssertNull(x);
1150 <                threadAssertSame(ex1, t);
1149 >                threadAssertSame(result, v1);
1150 >                threadAssertNull(t);
1151                  a.getAndIncrement();
1152 <                throw ex2;
1152 >                throw ex;
1153              });
1154 <        if (createIncomplete) f.completeExceptionally(ex1);
1154 >        if (createIncomplete) assertTrue(f.complete(v1));
1155  
1156 <        checkCompletedWithWrappedException(g, ex2);
1157 <        checkCompletedExceptionally(f, ex1);
1156 >        checkCompletedWithWrappedException(g, ex);
1157 >        checkCompletedNormally(f, v1);
1158          assertEquals(1, a.get());
1159      }}
1160  
1161      /**
1162       * If a "handle action" throws an exception when triggered by
1163 <     * a normal completion, it completes exceptionally
1163 >     * a source completion that also throws an exception, the action
1164 >     * exception takes precedence (unlike whenComplete)
1165       */
1166 <    public void testHandle_sourceCompletedNormallyActionFailed() {
1160 <        for (ExecutionMode m : ExecutionMode.values())
1166 >    public void testHandle_sourceFailedActionFailed() {
1167          for (boolean createIncomplete : new boolean[] { true, false })
1168 <        for (Integer v1 : new Integer[] { 1, null })
1168 >        for (ExecutionMode m : ExecutionMode.values())
1169      {
1164 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1170          final AtomicInteger a = new AtomicInteger(0);
1171 <        final CFException ex = new CFException();
1172 <        if (!createIncomplete) assertTrue(f.complete(v1));
1171 >        final CFException ex1 = new CFException();
1172 >        final CFException ex2 = new CFException();
1173 >        final CompletableFuture<Integer> f = new CompletableFuture<>();
1174 >
1175 >        if (!createIncomplete) f.completeExceptionally(ex1);
1176          final CompletableFuture<Integer> g = m.handle
1177              (f,
1178 <             (Integer x, Throwable t) -> {
1178 >             (Integer result, Throwable t) -> {
1179                  m.checkExecutionMode();
1180 <                threadAssertSame(x, v1);
1181 <                threadAssertNull(t);
1180 >                threadAssertNull(result);
1181 >                threadAssertSame(ex1, t);
1182                  a.getAndIncrement();
1183 <                throw ex;
1183 >                throw ex2;
1184              });
1185 <        if (createIncomplete) assertTrue(f.complete(v1));
1185 >        if (createIncomplete) f.completeExceptionally(ex1);
1186  
1187 <        checkCompletedWithWrappedException(g, ex);
1188 <        checkCompletedNormally(f, v1);
1187 >        checkCompletedWithWrappedException(g, ex2);
1188 >        checkCompletedExceptionally(f, ex1);
1189          assertEquals(1, a.get());
1190      }}
1191  
# Line 3648 | Line 3656 | public class CompletableFutureTest exten
3656          funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3657          funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3658  
3659 <        funs.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3659 >        funs.add((y) -> m.whenComplete(y, (Integer r, Throwable t) -> {}));
3660  
3661          funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3662  

Diff Legend

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