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.135 by jsr166, Sun Nov 15 20:03:08 2015 UTC

# Line 911 | Line 911 | public class CompletableFutureTest exten
911          if (!createIncomplete) assertTrue(f.complete(v1));
912          final CompletableFuture<Integer> g = m.whenComplete
913              (f,
914 <             (Integer x, Throwable t) -> {
914 >             (Integer result, Throwable t) -> {
915                  m.checkExecutionMode();
916 <                threadAssertSame(x, v1);
916 >                threadAssertSame(result, v1);
917                  threadAssertNull(t);
918                  a.getAndIncrement();
919              });
# Line 938 | Line 938 | public class CompletableFutureTest exten
938          if (!createIncomplete) f.completeExceptionally(ex);
939          final CompletableFuture<Integer> g = m.whenComplete
940              (f,
941 <             (Integer x, Throwable t) -> {
941 >             (Integer result, Throwable t) -> {
942                  m.checkExecutionMode();
943 <                threadAssertNull(x);
943 >                threadAssertNull(result);
944                  threadAssertSame(t, ex);
945                  a.getAndIncrement();
946              });
# Line 965 | Line 965 | public class CompletableFutureTest exten
965          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
966          final CompletableFuture<Integer> g = m.whenComplete
967              (f,
968 <             (Integer x, Throwable t) -> {
968 >             (Integer result, Throwable t) -> {
969                  m.checkExecutionMode();
970 <                threadAssertNull(x);
970 >                threadAssertNull(result);
971                  threadAssertTrue(t instanceof CancellationException);
972                  a.getAndIncrement();
973              });
# Line 993 | Line 993 | public class CompletableFutureTest exten
993          if (!createIncomplete) assertTrue(f.complete(v1));
994          final CompletableFuture<Integer> g = m.whenComplete
995              (f,
996 <             (Integer x, Throwable t) -> {
996 >             (Integer result, Throwable t) -> {
997                  m.checkExecutionMode();
998 <                threadAssertSame(x, v1);
998 >                threadAssertSame(result, v1);
999                  threadAssertNull(t);
1000                  a.getAndIncrement();
1001                  throw ex;
# Line 1024 | Line 1024 | public class CompletableFutureTest exten
1024          if (!createIncomplete) f.completeExceptionally(ex1);
1025          final CompletableFuture<Integer> g = m.whenComplete
1026              (f,
1027 <             (Integer x, Throwable t) -> {
1027 >             (Integer result, Throwable t) -> {
1028                  m.checkExecutionMode();
1029                  threadAssertSame(t, ex1);
1030 <                threadAssertNull(x);
1030 >                threadAssertNull(result);
1031                  a.getAndIncrement();
1032                  throw ex2;
1033              });
# Line 1052 | Line 1052 | public class CompletableFutureTest exten
1052          if (!createIncomplete) assertTrue(f.complete(v1));
1053          final CompletableFuture<Integer> g = m.handle
1054              (f,
1055 <             (Integer x, Throwable t) -> {
1055 >             (Integer result, Throwable t) -> {
1056                  m.checkExecutionMode();
1057 <                threadAssertSame(x, v1);
1057 >                threadAssertSame(result, v1);
1058                  threadAssertNull(t);
1059                  a.getAndIncrement();
1060                  return inc(v1);
# Line 1081 | Line 1081 | public class CompletableFutureTest exten
1081          if (!createIncomplete) f.completeExceptionally(ex);
1082          final CompletableFuture<Integer> g = m.handle
1083              (f,
1084 <             (Integer x, Throwable t) -> {
1084 >             (Integer result, Throwable t) -> {
1085                  m.checkExecutionMode();
1086 <                threadAssertNull(x);
1086 >                threadAssertNull(result);
1087                  threadAssertSame(t, ex);
1088                  a.getAndIncrement();
1089                  return v1;
# Line 1110 | Line 1110 | public class CompletableFutureTest exten
1110          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1111          final CompletableFuture<Integer> g = m.handle
1112              (f,
1113 <             (Integer x, Throwable t) -> {
1113 >             (Integer result, Throwable t) -> {
1114                  m.checkExecutionMode();
1115 <                threadAssertNull(x);
1115 >                threadAssertNull(result);
1116                  threadAssertTrue(t instanceof CancellationException);
1117                  a.getAndIncrement();
1118                  return v1;
# Line 1139 | Line 1139 | public class CompletableFutureTest exten
1139          if (!createIncomplete) assertTrue(f.complete(v1));
1140          final CompletableFuture<Integer> g = m.handle
1141              (f,
1142 <             (Integer x, Throwable t) -> {
1142 >             (Integer result, Throwable t) -> {
1143                  m.checkExecutionMode();
1144 <                threadAssertSame(x, v1);
1144 >                threadAssertSame(result, v1);
1145                  threadAssertNull(t);
1146                  a.getAndIncrement();
1147                  throw ex;
# Line 1170 | Line 1170 | public class CompletableFutureTest exten
1170          if (!createIncomplete) f.completeExceptionally(ex1);
1171          final CompletableFuture<Integer> g = m.handle
1172              (f,
1173 <             (Integer x, Throwable t) -> {
1173 >             (Integer result, Throwable t) -> {
1174                  m.checkExecutionMode();
1175 <                threadAssertNull(x);
1175 >                threadAssertNull(result);
1176                  threadAssertSame(ex1, t);
1177                  a.getAndIncrement();
1178                  throw ex2;
# Line 3651 | Line 3651 | public class CompletableFutureTest exten
3651          funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3652          funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3653  
3654 <        funs.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3654 >        funs.add((y) -> m.whenComplete(y, (Integer r, Throwable t) -> {}));
3655  
3656          funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3657  

Diff Legend

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