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.134 by jsr166, Sun Nov 15 19:55:38 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 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 1139 | Line 1144 | public class CompletableFutureTest exten
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 <                threadAssertSame(x, v1);
1149 >                threadAssertSame(result, v1);
1150                  threadAssertNull(t);
1151                  a.getAndIncrement();
1152                  throw ex;
# Line 1170 | Line 1175 | public class CompletableFutureTest exten
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 <                threadAssertNull(x);
1180 >                threadAssertNull(result);
1181                  threadAssertSame(ex1, t);
1182                  a.getAndIncrement();
1183                  throw ex2;
# Line 3651 | 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