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.53 by jsr166, Mon Jun 2 20:20:47 2014 UTC vs.
Revision 1.58 by jsr166, Mon Jun 2 23:10:08 2014 UTC

# Line 284 | Line 284 | public class CompletableFutureTest exten
284      public void testGetNumberOfDependents() {
285          CompletableFuture<Integer> f = new CompletableFuture<>();
286          assertEquals(0, f.getNumberOfDependents());
287 <        CompletableFuture g = f.thenRun(new Noop());
287 >        CompletableFuture g = f.thenRun(new Noop(ExecutionMode.DEFAULT));
288          assertEquals(1, f.getNumberOfDependents());
289          assertEquals(0, g.getNumberOfDependents());
290 <        CompletableFuture h = f.thenRun(new Noop());
290 >        CompletableFuture h = f.thenRun(new Noop(ExecutionMode.DEFAULT));
291          assertEquals(2, f.getNumberOfDependents());
292          f.complete(1);
293          checkCompletedNormally(g, null);
# Line 334 | Line 334 | public class CompletableFutureTest exten
334          return (x == null) ? null : x + 1;
335      }
336  
337 <    static final Supplier<Integer> supplyOne =
338 <        () -> Integer.valueOf(1);
339 <    static final Function<Integer, Integer> inc =
340 <        (Integer x) -> Integer.valueOf(x.intValue() + 1);
341 <    static final BiFunction<Integer, Integer, Integer> subtract =
342 <        (Integer x, Integer y) -> subtract(x, y);
337 >    static final class IntegerSupplier implements Supplier<Integer> {
338 >        final ExecutionMode m;
339 >        int invocationCount = 0;
340 >        final Integer value;
341 >        IntegerSupplier(ExecutionMode m, Integer value) {
342 >            this.m = m;
343 >            this.value = value;
344 >        }
345 >        public Integer get() {
346 >            m.checkExecutionMode();
347 >            invocationCount++;
348 >            return value;
349 >        }
350 >    }
351 >        
352      static final class IncAction implements Consumer<Integer> {
353          int invocationCount = 0;
354          Integer value;
# Line 349 | Line 358 | public class CompletableFutureTest exten
358          }
359      }
360      static final class IncFunction implements Function<Integer,Integer> {
361 +        final ExecutionMode m;
362          int invocationCount = 0;
363          Integer value;
364 +        IncFunction(ExecutionMode m) { this.m = m; }
365          public Integer apply(Integer x) {
366 +            m.checkExecutionMode();
367              invocationCount++;
368              return value = inc(x);
369          }
370      }
371      static final class SubtractAction implements BiConsumer<Integer, Integer> {
372 +        final ExecutionMode m;
373          int invocationCount = 0;
374          Integer value;
375          // Check this action was invoked exactly once when result is computed.
376 +        SubtractAction(ExecutionMode m) { this.m = m; }
377          public void accept(Integer x, Integer y) {
378 +            m.checkExecutionMode();
379              invocationCount++;
380              value = subtract(x, y);
381          }
382      }
383      static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
384 +        final ExecutionMode m;
385          int invocationCount = 0;
386          Integer value;
387          // Check this action was invoked exactly once when result is computed.
388 +        SubtractFunction(ExecutionMode m) { this.m = m; }
389          public Integer apply(Integer x, Integer y) {
390 +            m.checkExecutionMode();
391              invocationCount++;
392              return value = subtract(x, y);
393          }
394      }
395      static final class Noop implements Runnable {
396 +        final ExecutionMode m;
397          int invocationCount = 0;
398 +        Noop(ExecutionMode m) { this.m = m; }
399          public void run() {
400 +            m.checkExecutionMode();
401              invocationCount++;
402          }
403      }
404  
405      static final class FailingSupplier implements Supplier<Integer> {
406 +        final ExecutionMode m;
407          int invocationCount = 0;
408 +        FailingSupplier(ExecutionMode m) { this.m = m; }
409          public Integer get() {
410 +            m.checkExecutionMode();
411              invocationCount++;
412              throw new CFException();
413          }
414      }
415      static final class FailingConsumer implements Consumer<Integer> {
416 +        final ExecutionMode m;
417          int invocationCount = 0;
418 +        FailingConsumer(ExecutionMode m) { this.m = m; }
419          public void accept(Integer x) {
420 +            m.checkExecutionMode();
421              invocationCount++;
422              throw new CFException();
423          }
424      }
425      static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
426 +        final ExecutionMode m;
427          int invocationCount = 0;
428 +        FailingBiConsumer(ExecutionMode m) { this.m = m; }
429          public void accept(Integer x, Integer y) {
430 +            m.checkExecutionMode();
431              invocationCount++;
432              throw new CFException();
433          }
434      }
435      static final class FailingFunction implements Function<Integer, Integer> {
436 +        final ExecutionMode m;
437          int invocationCount = 0;
438 +        FailingFunction(ExecutionMode m) { this.m = m; }
439          public Integer apply(Integer x) {
440 +            m.checkExecutionMode();
441              invocationCount++;
442              throw new CFException();
443          }
444      }
445      static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
446 +        final ExecutionMode m;
447          int invocationCount = 0;
448 +        FailingBiFunction(ExecutionMode m) { this.m = m; }
449          public Integer apply(Integer x, Integer y) {
450 +            m.checkExecutionMode();
451              invocationCount++;
452              throw new CFException();
453          }
454      }
455      static final class FailingRunnable implements Runnable {
456 +        final ExecutionMode m;
457          int invocationCount = 0;
458 +        FailingRunnable(ExecutionMode m) { this.m = m; }
459          public void run() {
460 +            m.checkExecutionMode();
461              invocationCount++;
462              throw new CFException();
463          }
# Line 426 | Line 465 | public class CompletableFutureTest exten
465  
466      static final class CompletableFutureInc
467          implements Function<Integer, CompletableFuture<Integer>> {
468 +        final ExecutionMode m;
469          int invocationCount = 0;
470 +        CompletableFutureInc(ExecutionMode m) { this.m = m; }
471          public CompletableFuture<Integer> apply(Integer x) {
472 +            m.checkExecutionMode();
473              invocationCount++;
474              CompletableFuture<Integer> f = new CompletableFuture<>();
475              f.complete(inc(x));
# Line 437 | Line 479 | public class CompletableFutureTest exten
479  
480      static final class FailingCompletableFutureFunction
481          implements Function<Integer, CompletableFuture<Integer>> {
482 +        final ExecutionMode m;
483          int invocationCount = 0;
484 +        FailingCompletableFutureFunction(ExecutionMode m) { this.m = m; }
485          public CompletableFuture<Integer> apply(Integer x) {
486 +            m.checkExecutionMode();
487              invocationCount++;
488              throw new CFException();
489          }
# Line 446 | Line 491 | public class CompletableFutureTest exten
491  
492      // Used for explicit executor tests
493      static final class ThreadExecutor implements Executor {
494 <        AtomicInteger count = new AtomicInteger(0);
494 >        final AtomicInteger count = new AtomicInteger(0);
495 >        static final ThreadGroup tg = new ThreadGroup("ThreadExecutor");
496 >        static boolean startedCurrentThread() {
497 >            return Thread.currentThread().getThreadGroup() == tg;
498 >        }
499  
500          public void execute(Runnable r) {
501              count.getAndIncrement();
502 <            new Thread(r).start();
502 >            new Thread(tg, r).start();
503          }
504      }
505  
# Line 463 | Line 512 | public class CompletableFutureTest exten
512              public void checkExecutionMode() {
513                  assertNull(ForkJoinTask.getPool());
514              }
515 +            public CompletableFuture<Void> runAsync(Runnable a) {
516 +                throw new UnsupportedOperationException();
517 +            }
518 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
519 +                throw new UnsupportedOperationException();
520 +            }
521              public <T> CompletableFuture<Void> thenRun
522                  (CompletableFuture<T> f, Runnable a) {
523                  return f.thenRun(a);
# Line 531 | Line 586 | public class CompletableFutureTest exten
586                  assertSame(ForkJoinPool.commonPool(),
587                             ForkJoinTask.getPool());
588              }
589 +            public CompletableFuture<Void> runAsync(Runnable a) {
590 +                return CompletableFuture.runAsync(a);
591 +            }
592 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
593 +                return CompletableFuture.supplyAsync(a);
594 +            }
595              public <T> CompletableFuture<Void> thenRun
596                  (CompletableFuture<T> f, Runnable a) {
597                  return f.thenRunAsync(a);
# Line 596 | Line 657 | public class CompletableFutureTest exten
657  
658          EXECUTOR {
659              public void checkExecutionMode() {
660 <                //TODO
660 >                assertTrue(ThreadExecutor.startedCurrentThread());
661 >            }
662 >            public CompletableFuture<Void> runAsync(Runnable a) {
663 >                return CompletableFuture.runAsync(a, new ThreadExecutor());
664 >            }
665 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
666 >                return CompletableFuture.supplyAsync(a, new ThreadExecutor());
667              }
668              public <T> CompletableFuture<Void> thenRun
669                  (CompletableFuture<T> f, Runnable a) {
# Line 662 | Line 729 | public class CompletableFutureTest exten
729          };
730  
731          public abstract void checkExecutionMode();
732 +        public abstract CompletableFuture<Void> runAsync(Runnable a);
733 +        public abstract <U> CompletableFuture<U> supplyAsync(Supplier<U> a);
734          public abstract <T> CompletableFuture<Void> thenRun
735              (CompletableFuture<T> f, Runnable a);
736          public abstract <T> CompletableFuture<Void> thenAccept
# Line 740 | Line 809 | public class CompletableFutureTest exten
809          if (!createIncomplete) f.completeExceptionally(ex);
810          final CompletableFuture<Integer> g = f.exceptionally
811              ((Throwable t) -> {
812 +                ExecutionMode.DEFAULT.checkExecutionMode();
813                  threadAssertSame(t, ex);
814                  a.getAndIncrement();
815                  return v1;
# Line 761 | Line 831 | public class CompletableFutureTest exten
831          if (!createIncomplete) f.completeExceptionally(ex1);
832          final CompletableFuture<Integer> g = f.exceptionally
833              ((Throwable t) -> {
834 +                ExecutionMode.DEFAULT.checkExecutionMode();
835                  threadAssertSame(t, ex1);
836                  a.getAndIncrement();
837                  throw ex2;
# Line 786 | Line 857 | public class CompletableFutureTest exten
857          final CompletableFuture<Integer> g = m.handle
858              (f,
859               (Integer x, Throwable t) -> {
860 +                m.checkExecutionMode();
861                  threadAssertSame(x, v1);
862                  threadAssertNull(t);
863                  a.getAndIncrement();
# Line 814 | Line 886 | public class CompletableFutureTest exten
886          final CompletableFuture<Integer> g = m.handle
887              (f,
888               (Integer x, Throwable t) -> {
889 +                m.checkExecutionMode();
890                  threadAssertNull(x);
891                  threadAssertSame(t, ex);
892                  a.getAndIncrement();
# Line 842 | Line 915 | public class CompletableFutureTest exten
915          final CompletableFuture<Integer> g = m.handle
916              (f,
917               (Integer x, Throwable t) -> {
918 +                m.checkExecutionMode();
919                  threadAssertNull(x);
920                  threadAssertTrue(t instanceof CancellationException);
921                  a.getAndIncrement();
# Line 869 | Line 943 | public class CompletableFutureTest exten
943          final CompletableFuture<Integer> g = m.handle
944              (f,
945               (Integer x, Throwable t) -> {
946 +                m.checkExecutionMode();
947                  threadAssertNull(x);
948                  threadAssertSame(ex1, t);
949                  a.getAndIncrement();
# Line 893 | Line 968 | public class CompletableFutureTest exten
968          final CompletableFuture<Integer> g = m.handle
969              (f,
970               (Integer x, Throwable t) -> {
971 +                m.checkExecutionMode();
972                  threadAssertSame(x, v1);
973                  threadAssertNull(t);
974                  a.getAndIncrement();
# Line 908 | Line 984 | public class CompletableFutureTest exten
984      /**
985       * runAsync completes after running Runnable
986       */
987 <    public void testRunAsync() {
988 <        Noop r = new Noop();
989 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
987 >    public void testRunAsync_normalCompletion() {
988 >        ExecutionMode[] executionModes = {
989 >            ExecutionMode.ASYNC,
990 >            ExecutionMode.EXECUTOR,
991 >        };
992 >        for (ExecutionMode m : executionModes)
993 >    {
994 >        final Noop r = new Noop(m);
995 >        final CompletableFuture<Void> f = m.runAsync(r);
996          assertNull(f.join());
915        assertEquals(1, r.invocationCount);
997          checkCompletedNormally(f, null);
917    }
918
919    /**
920     * runAsync with executor completes after running Runnable
921     */
922    public void testRunAsync2() {
923        Noop r = new Noop();
924        ThreadExecutor exec = new ThreadExecutor();
925        CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
926        assertNull(f.join());
998          assertEquals(1, r.invocationCount);
999 <        checkCompletedNormally(f, null);
929 <        assertEquals(1, exec.count.get());
930 <    }
999 >    }}
1000  
1001      /**
1002       * failing runAsync completes exceptionally after running Runnable
1003       */
1004 <    public void testRunAsync3() {
1005 <        FailingRunnable r = new FailingRunnable();
1006 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
1004 >    public void testRunAsync_exceptionalCompletion() {
1005 >        ExecutionMode[] executionModes = {
1006 >            ExecutionMode.ASYNC,
1007 >            ExecutionMode.EXECUTOR,
1008 >        };
1009 >        for (ExecutionMode m : executionModes)
1010 >    {
1011 >        final FailingRunnable r = new FailingRunnable(m);
1012 >        final CompletableFuture<Void> f = m.runAsync(r);
1013          checkCompletedWithWrappedCFException(f);
1014          assertEquals(1, r.invocationCount);
1015 <    }
1015 >    }}
1016  
1017      /**
1018       * supplyAsync completes with result of supplier
1019       */
1020 <    public void testSupplyAsync() {
1021 <        CompletableFuture<Integer> f;
1022 <        f = CompletableFuture.supplyAsync(supplyOne);
1023 <        assertEquals(f.join(), one);
1024 <        checkCompletedNormally(f, one);
1025 <    }
1026 <
1027 <    /**
1028 <     * supplyAsync with executor completes with result of supplier
1029 <     */
1030 <    public void testSupplyAsync2() {
1031 <        CompletableFuture<Integer> f;
1032 <        f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
1033 <        assertEquals(f.join(), one);
959 <        checkCompletedNormally(f, one);
960 <    }
1020 >    public void testSupplyAsync_normalCompletion() {
1021 >        ExecutionMode[] executionModes = {
1022 >            ExecutionMode.ASYNC,
1023 >            ExecutionMode.EXECUTOR,
1024 >        };
1025 >        for (ExecutionMode m : executionModes)
1026 >        for (Integer v1 : new Integer[] { 1, null })
1027 >    {
1028 >        final IntegerSupplier r = new IntegerSupplier(m, v1);
1029 >        final CompletableFuture<Integer> f = m.supplyAsync(r);
1030 >        assertSame(v1, f.join());
1031 >        checkCompletedNormally(f, v1);
1032 >        assertEquals(1, r.invocationCount);
1033 >    }}
1034  
1035      /**
1036       * Failing supplyAsync completes exceptionally
1037       */
1038 <    public void testSupplyAsync3() {
1039 <        FailingSupplier r = new FailingSupplier();
1040 <        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
1038 >    public void testSupplyAsync_exceptionalCompletion() {
1039 >        ExecutionMode[] executionModes = {
1040 >            ExecutionMode.ASYNC,
1041 >            ExecutionMode.EXECUTOR,
1042 >        };
1043 >        for (ExecutionMode m : executionModes)
1044 >    {
1045 >        FailingSupplier r = new FailingSupplier(m);
1046 >        CompletableFuture<Integer> f = m.supplyAsync(r);
1047          checkCompletedWithWrappedCFException(f);
1048          assertEquals(1, r.invocationCount);
1049 <    }
1049 >    }}
1050  
1051      // seq completion methods
1052  
# Line 980 | Line 1059 | public class CompletableFutureTest exten
1059          for (Integer v1 : new Integer[] { 1, null })
1060      {
1061          final CompletableFuture<Integer> f = new CompletableFuture<>();
1062 <        final Noop r = new Noop();
1062 >        final Noop r = new Noop(m);
1063          if (!createIncomplete) f.complete(v1);
1064          final CompletableFuture<Void> g = m.thenRun(f, r);
1065          if (createIncomplete) {
# Line 1003 | Line 1082 | public class CompletableFutureTest exten
1082      {
1083          final CFException ex = new CFException();
1084          final CompletableFuture<Integer> f = new CompletableFuture<>();
1085 <        final Noop r = new Noop();
1085 >        final Noop r = new Noop(m);
1086          if (!createIncomplete) f.completeExceptionally(ex);
1087          final CompletableFuture<Void> g = m.thenRun(f, r);
1088          if (createIncomplete) {
# Line 1025 | Line 1104 | public class CompletableFutureTest exten
1104          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1105      {
1106          final CompletableFuture<Integer> f = new CompletableFuture<>();
1107 <        final Noop r = new Noop();
1107 >        final Noop r = new Noop(m);
1108          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1109 <        final CompletableFuture<Void> g = f.thenRun(r);
1109 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1110          if (createIncomplete) {
1111              checkIncomplete(g);
1112              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1047 | Line 1126 | public class CompletableFutureTest exten
1126          for (Integer v1 : new Integer[] { 1, null })
1127      {
1128          final CompletableFuture<Integer> f = new CompletableFuture<>();
1129 <        final FailingRunnable r = new FailingRunnable();
1129 >        final FailingRunnable r = new FailingRunnable(m);
1130          if (!createIncomplete) f.complete(v1);
1131 <        final CompletableFuture<Void> g = f.thenRun(r);
1131 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1132          if (createIncomplete) {
1133              checkIncomplete(g);
1134              f.complete(v1);
# Line 1068 | Line 1147 | public class CompletableFutureTest exten
1147          for (Integer v1 : new Integer[] { 1, null })
1148      {
1149          final CompletableFuture<Integer> f = new CompletableFuture<>();
1150 <        final IncFunction r = new IncFunction();
1150 >        final IncFunction r = new IncFunction(m);
1151          if (!createIncomplete) f.complete(v1);
1152          final CompletableFuture<Integer> g = m.thenApply(f, r);
1153          if (createIncomplete) {
# Line 1091 | Line 1170 | public class CompletableFutureTest exten
1170      {
1171          final CFException ex = new CFException();
1172          final CompletableFuture<Integer> f = new CompletableFuture<>();
1173 <        final IncFunction r = new IncFunction();
1173 >        final IncFunction r = new IncFunction(m);
1174          if (!createIncomplete) f.completeExceptionally(ex);
1175          final CompletableFuture<Integer> g = m.thenApply(f, r);
1176          if (createIncomplete) {
# Line 1113 | Line 1192 | public class CompletableFutureTest exten
1192          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1193      {
1194          final CompletableFuture<Integer> f = new CompletableFuture<>();
1195 <        final IncFunction r = new IncFunction();
1195 >        final IncFunction r = new IncFunction(m);
1196          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1197 <        final CompletableFuture<Integer> g = f.thenApply(r);
1197 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1198          if (createIncomplete) {
1199              checkIncomplete(g);
1200              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1135 | Line 1214 | public class CompletableFutureTest exten
1214          for (Integer v1 : new Integer[] { 1, null })
1215      {
1216          final CompletableFuture<Integer> f = new CompletableFuture<>();
1217 <        final FailingFunction r = new FailingFunction();
1217 >        final FailingFunction r = new FailingFunction(m);
1218          if (!createIncomplete) f.complete(v1);
1219 <        final CompletableFuture<Integer> g = f.thenApply(r);
1219 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1220          if (createIncomplete) {
1221              checkIncomplete(g);
1222              f.complete(v1);
# Line 1202 | Line 1281 | public class CompletableFutureTest exten
1281          for (Integer v1 : new Integer[] { 1, null })
1282      {
1283          final CompletableFuture<Integer> f = new CompletableFuture<>();
1284 <        final FailingConsumer r = new FailingConsumer();
1284 >        final FailingConsumer r = new FailingConsumer(m);
1285          if (!createIncomplete) f.complete(v1);
1286 <        final CompletableFuture<Void> g = f.thenAccept(r);
1286 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1287          if (createIncomplete) {
1288              checkIncomplete(g);
1289              f.complete(v1);
# Line 1225 | Line 1304 | public class CompletableFutureTest exten
1304          final CompletableFuture<Integer> f = new CompletableFuture<>();
1305          final IncAction r = new IncAction();
1306          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1307 <        final CompletableFuture<Void> g = f.thenAccept(r);
1307 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1308          if (createIncomplete) {
1309              checkIncomplete(g);
1310              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1249 | Line 1328 | public class CompletableFutureTest exten
1328      {
1329          final CompletableFuture<Integer> f = new CompletableFuture<>();
1330          final CompletableFuture<Integer> g = new CompletableFuture<>();
1331 <        final SubtractFunction r = new SubtractFunction();
1331 >        final SubtractFunction r = new SubtractFunction(m);
1332  
1333          if (fFirst) f.complete(v1); else g.complete(v2);
1334          if (!createIncomplete)
# Line 1280 | Line 1359 | public class CompletableFutureTest exten
1359          final CompletableFuture<Integer> f = new CompletableFuture<>();
1360          final CompletableFuture<Integer> g = new CompletableFuture<>();
1361          final CFException ex = new CFException();
1362 <        final SubtractFunction r = new SubtractFunction();
1362 >        final SubtractFunction r = new SubtractFunction(m);
1363  
1364          (fFirst ? f : g).complete(v1);
1365          if (!createIncomplete)
# Line 1308 | Line 1387 | public class CompletableFutureTest exten
1387      {
1388          final CompletableFuture<Integer> f = new CompletableFuture<>();
1389          final CompletableFuture<Integer> g = new CompletableFuture<>();
1390 <        final FailingBiFunction r = new FailingBiFunction();
1390 >        final FailingBiFunction r = new FailingBiFunction(m);
1391          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1392  
1393          if (fFirst) {
# Line 1336 | Line 1415 | public class CompletableFutureTest exten
1415      {
1416          final CompletableFuture<Integer> f = new CompletableFuture<>();
1417          final CompletableFuture<Integer> g = new CompletableFuture<>();
1418 <        final SubtractFunction r = new SubtractFunction();
1418 >        final SubtractFunction r = new SubtractFunction(m);
1419  
1420          (fFirst ? f : g).complete(v1);
1421          if (!createIncomplete)
# Line 1366 | Line 1445 | public class CompletableFutureTest exten
1445      {
1446          final CompletableFuture<Integer> f = new CompletableFuture<>();
1447          final CompletableFuture<Integer> g = new CompletableFuture<>();
1448 <        final SubtractAction r = new SubtractAction();
1448 >        final SubtractAction r = new SubtractAction(m);
1449  
1450          if (fFirst) f.complete(v1); else g.complete(v2);
1451          if (!createIncomplete)
# Line 1397 | Line 1476 | public class CompletableFutureTest exten
1476          final CompletableFuture<Integer> f = new CompletableFuture<>();
1477          final CompletableFuture<Integer> g = new CompletableFuture<>();
1478          final CFException ex = new CFException();
1479 <        final SubtractAction r = new SubtractAction();
1479 >        final SubtractAction r = new SubtractAction(m);
1480  
1481          (fFirst ? f : g).complete(v1);
1482          if (!createIncomplete)
# Line 1425 | Line 1504 | public class CompletableFutureTest exten
1504      {
1505          final CompletableFuture<Integer> f = new CompletableFuture<>();
1506          final CompletableFuture<Integer> g = new CompletableFuture<>();
1507 <        final FailingBiConsumer r = new FailingBiConsumer();
1507 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1508          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1509  
1510          if (fFirst) {
# Line 1453 | Line 1532 | public class CompletableFutureTest exten
1532      {
1533          final CompletableFuture<Integer> f = new CompletableFuture<>();
1534          final CompletableFuture<Integer> g = new CompletableFuture<>();
1535 <        final SubtractAction r = new SubtractAction();
1535 >        final SubtractAction r = new SubtractAction(m);
1536  
1537          (fFirst ? f : g).complete(v1);
1538          if (!createIncomplete)
# Line 1474 | Line 1553 | public class CompletableFutureTest exten
1553       * runAfterBoth result completes normally after normal
1554       * completion of sources
1555       */
1556 <    public void testRunAfterBoth_normalCompletion1() {
1478 <        for (ExecutionMode m : ExecutionMode.values())
1479 <        for (Integer v1 : new Integer[] { 1, null })
1480 <        for (Integer v2 : new Integer[] { 2, null })
1481 <    {
1482 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1483 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1484 <        final Noop r = new Noop();
1485 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1486 <
1487 <        f.complete(v1);
1488 <        checkIncomplete(h);
1489 <        assertEquals(0, r.invocationCount);
1490 <        g.complete(v2);
1491 <
1492 <        checkCompletedNormally(h, null);
1493 <        assertEquals(1, r.invocationCount);
1494 <        checkCompletedNormally(f, v1);
1495 <        checkCompletedNormally(g, v2);
1496 <    }}
1497 <
1498 <    public void testRunAfterBoth_normalCompletion2() {
1499 <        for (ExecutionMode m : ExecutionMode.values())
1500 <        for (Integer v1 : new Integer[] { 1, null })
1501 <        for (Integer v2 : new Integer[] { 2, null })
1502 <    {
1503 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1504 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1505 <        final Noop r = new Noop();
1506 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1507 <
1508 <        g.complete(v2);
1509 <        checkIncomplete(h);
1510 <        assertEquals(0, r.invocationCount);
1511 <        f.complete(v1);
1512 <
1513 <        checkCompletedNormally(h, null);
1514 <        assertEquals(1, r.invocationCount);
1515 <        checkCompletedNormally(f, v1);
1516 <        checkCompletedNormally(g, v2);
1517 <    }}
1518 <
1519 <    public void testRunAfterBoth_normalCompletion3() {
1520 <        for (ExecutionMode m : ExecutionMode.values())
1521 <        for (Integer v1 : new Integer[] { 1, null })
1522 <        for (Integer v2 : new Integer[] { 2, null })
1523 <    {
1524 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1525 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1526 <        final Noop r = new Noop();
1527 <
1528 <        g.complete(v2);
1529 <        f.complete(v1);
1530 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1531 <
1532 <        checkCompletedNormally(h, null);
1533 <        assertEquals(1, r.invocationCount);
1534 <        checkCompletedNormally(f, v1);
1535 <        checkCompletedNormally(g, v2);
1536 <    }}
1537 <
1538 <    public void testRunAfterBoth_normalCompletion4() {
1556 >    public void testRunAfterBoth_normalCompletion() {
1557          for (ExecutionMode m : ExecutionMode.values())
1558 +        for (boolean createIncomplete : new boolean[] { true, false })
1559 +        for (boolean fFirst : new boolean[] { true, false })
1560          for (Integer v1 : new Integer[] { 1, null })
1561          for (Integer v2 : new Integer[] { 2, null })
1562      {
1563          final CompletableFuture<Integer> f = new CompletableFuture<>();
1564          final CompletableFuture<Integer> g = new CompletableFuture<>();
1565 <        final Noop r = new Noop();
1565 >        final Noop r = new Noop(m);
1566  
1567 <        f.complete(v1);
1568 <        g.complete(v2);
1567 >        if (fFirst) f.complete(v1); else g.complete(v2);
1568 >        if (!createIncomplete)
1569 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1570          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1571 +        if (createIncomplete) {
1572 +            checkIncomplete(h);
1573 +            assertEquals(0, r.invocationCount);
1574 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1575 +        }
1576  
1577          checkCompletedNormally(h, null);
1578          assertEquals(1, r.invocationCount);
# Line 1558 | Line 1584 | public class CompletableFutureTest exten
1584       * runAfterBoth result completes exceptionally after exceptional
1585       * completion of either source
1586       */
1587 <    public void testRunAfterBoth_exceptionalCompletion1() {
1562 <        for (ExecutionMode m : ExecutionMode.values())
1563 <        for (Integer v1 : new Integer[] { 1, null })
1564 <    {
1565 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1566 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1567 <        final Noop r = new Noop();
1568 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1569 <        final CFException ex = new CFException();
1570 <
1571 <        f.completeExceptionally(ex);
1572 <        checkIncomplete(h);
1573 <        g.complete(v1);
1574 <
1575 <        checkCompletedWithWrappedCFException(h, ex);
1576 <        checkCompletedWithWrappedCFException(f, ex);
1577 <        assertEquals(0, r.invocationCount);
1578 <        checkCompletedNormally(g, v1);
1579 <    }}
1580 <
1581 <    public void testRunAfterBoth_exceptionalCompletion2() {
1582 <        for (ExecutionMode m : ExecutionMode.values())
1583 <        for (Integer v1 : new Integer[] { 1, null })
1584 <    {
1585 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1586 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1587 <        final Noop r = new Noop();
1588 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1589 <        final CFException ex = new CFException();
1590 <
1591 <        g.completeExceptionally(ex);
1592 <        checkIncomplete(h);
1593 <        f.complete(v1);
1594 <
1595 <        checkCompletedWithWrappedCFException(h, ex);
1596 <        checkCompletedWithWrappedCFException(g, ex);
1597 <        assertEquals(0, r.invocationCount);
1598 <        checkCompletedNormally(f, v1);
1599 <    }}
1600 <
1601 <    public void testRunAfterBoth_exceptionalCompletion3() {
1602 <        for (ExecutionMode m : ExecutionMode.values())
1603 <        for (Integer v1 : new Integer[] { 1, null })
1604 <    {
1605 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1606 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1607 <        final Noop r = new Noop();
1608 <        final CFException ex = new CFException();
1609 <
1610 <        g.completeExceptionally(ex);
1611 <        f.complete(v1);
1612 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1613 <
1614 <        checkCompletedWithWrappedCFException(h, ex);
1615 <        checkCompletedWithWrappedCFException(g, ex);
1616 <        assertEquals(0, r.invocationCount);
1617 <        checkCompletedNormally(f, v1);
1618 <    }}
1619 <
1620 <    public void testRunAfterBoth_exceptionalCompletion4() {
1587 >    public void testRunAfterBoth_exceptionalCompletion() {
1588          for (ExecutionMode m : ExecutionMode.values())
1589 +        for (boolean createIncomplete : new boolean[] { true, false })
1590 +        for (boolean fFirst : new boolean[] { true, false })
1591          for (Integer v1 : new Integer[] { 1, null })
1592      {
1593          final CompletableFuture<Integer> f = new CompletableFuture<>();
1594          final CompletableFuture<Integer> g = new CompletableFuture<>();
1626        final Noop r = new Noop();
1595          final CFException ex = new CFException();
1596 +        final Noop r = new Noop(m);
1597  
1598 <        f.completeExceptionally(ex);
1599 <        g.complete(v1);
1598 >        (fFirst ? f : g).complete(v1);
1599 >        if (!createIncomplete)
1600 >            (!fFirst ? f : g).completeExceptionally(ex);
1601          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1602 +        if (createIncomplete) {
1603 +            checkIncomplete(h);
1604 +            (!fFirst ? f : g).completeExceptionally(ex);
1605 +        }
1606  
1607          checkCompletedWithWrappedCFException(h, ex);
1634        checkCompletedWithWrappedCFException(f, ex);
1608          assertEquals(0, r.invocationCount);
1609 <        checkCompletedNormally(g, v1);
1609 >        checkCompletedNormally(fFirst ? f : g, v1);
1610 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1611      }}
1612  
1613      /**
1614       * runAfterBoth result completes exceptionally if action does
1615       */
1616 <    public void testRunAfterBoth_actionFailed1() {
1643 <        for (ExecutionMode m : ExecutionMode.values())
1644 <        for (Integer v1 : new Integer[] { 1, null })
1645 <        for (Integer v2 : new Integer[] { 2, null })
1646 <    {
1647 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1648 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1649 <        final FailingRunnable r = new FailingRunnable();
1650 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1651 <
1652 <        f.complete(v1);
1653 <        checkIncomplete(h);
1654 <        g.complete(v2);
1655 <
1656 <        checkCompletedWithWrappedCFException(h);
1657 <        checkCompletedNormally(f, v1);
1658 <        checkCompletedNormally(g, v2);
1659 <    }}
1660 <
1661 <    public void testRunAfterBoth_actionFailed2() {
1616 >    public void testRunAfterBoth_actionFailed() {
1617          for (ExecutionMode m : ExecutionMode.values())
1618 +        for (boolean fFirst : new boolean[] { true, false })
1619          for (Integer v1 : new Integer[] { 1, null })
1620          for (Integer v2 : new Integer[] { 2, null })
1621      {
1622          final CompletableFuture<Integer> f = new CompletableFuture<>();
1623          final CompletableFuture<Integer> g = new CompletableFuture<>();
1624 <        final FailingRunnable r = new FailingRunnable();
1669 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1624 >        final FailingRunnable r = new FailingRunnable(m);
1625  
1626 <        g.complete(v2);
1627 <        checkIncomplete(h);
1628 <        f.complete(v1);
1626 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r);
1627 >        if (fFirst) {
1628 >            f.complete(v1);
1629 >            g.complete(v2);
1630 >        } else {
1631 >            g.complete(v2);
1632 >            f.complete(v1);
1633 >        }
1634 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r);
1635  
1636 <        checkCompletedWithWrappedCFException(h);
1636 >        checkCompletedWithWrappedCFException(h1);
1637 >        checkCompletedWithWrappedCFException(h2);
1638          checkCompletedNormally(f, v1);
1639          checkCompletedNormally(g, v2);
1640      }}
# Line 1680 | Line 1642 | public class CompletableFutureTest exten
1642      /**
1643       * runAfterBoth result completes exceptionally if either source cancelled
1644       */
1645 <    public void testRunAfterBoth_sourceCancelled1() {
1684 <        for (ExecutionMode m : ExecutionMode.values())
1685 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1686 <        for (Integer v1 : new Integer[] { 1, null })
1687 <    {
1688 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1689 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1690 <        final Noop r = new Noop();
1691 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1692 <
1693 <        assertTrue(f.cancel(mayInterruptIfRunning));
1694 <        checkIncomplete(h);
1695 <        g.complete(v1);
1696 <
1697 <        checkCompletedWithWrappedCancellationException(h);
1698 <        checkCancelled(f);
1699 <        assertEquals(0, r.invocationCount);
1700 <        checkCompletedNormally(g, v1);
1701 <    }}
1702 <
1703 <    public void testRunAfterBoth_sourceCancelled2() {
1704 <        for (ExecutionMode m : ExecutionMode.values())
1705 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1706 <        for (Integer v1 : new Integer[] { 1, null })
1707 <    {
1708 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1709 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1710 <        final Noop r = new Noop();
1711 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1712 <
1713 <        assertTrue(g.cancel(mayInterruptIfRunning));
1714 <        checkIncomplete(h);
1715 <        f.complete(v1);
1716 <
1717 <        checkCompletedWithWrappedCancellationException(h);
1718 <        checkCancelled(g);
1719 <        assertEquals(0, r.invocationCount);
1720 <        checkCompletedNormally(f, v1);
1721 <    }}
1722 <
1723 <    public void testRunAfterBoth_sourceCancelled3() {
1645 >    public void testRunAfterBoth_sourceCancelled() {
1646          for (ExecutionMode m : ExecutionMode.values())
1647          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1648 +        for (boolean createIncomplete : new boolean[] { true, false })
1649 +        for (boolean fFirst : new boolean[] { true, false })
1650          for (Integer v1 : new Integer[] { 1, null })
1651      {
1652          final CompletableFuture<Integer> f = new CompletableFuture<>();
1653          final CompletableFuture<Integer> g = new CompletableFuture<>();
1654 <        final Noop r = new Noop();
1731 <
1732 <        assertTrue(g.cancel(mayInterruptIfRunning));
1733 <        f.complete(v1);
1734 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1735 <
1736 <        checkCompletedWithWrappedCancellationException(h);
1737 <        checkCancelled(g);
1738 <        assertEquals(0, r.invocationCount);
1739 <        checkCompletedNormally(f, v1);
1740 <    }}
1654 >        final Noop r = new Noop(m);
1655  
1742    public void testRunAfterBoth_sourceCancelled4() {
1743        for (ExecutionMode m : ExecutionMode.values())
1744        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1745        for (Integer v1 : new Integer[] { 1, null })
1746    {
1747        final CompletableFuture<Integer> f = new CompletableFuture<>();
1748        final CompletableFuture<Integer> g = new CompletableFuture<>();
1749        final Noop r = new Noop();
1656  
1657 <        assertTrue(f.cancel(mayInterruptIfRunning));
1658 <        g.complete(v1);
1657 >        (fFirst ? f : g).complete(v1);
1658 >        if (!createIncomplete)
1659 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1660          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1661 +        if (createIncomplete) {
1662 +            checkIncomplete(h);
1663 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1664 +        }
1665  
1666          checkCompletedWithWrappedCancellationException(h);
1667 <        checkCancelled(f);
1667 >        checkCancelled(!fFirst ? f : g);
1668          assertEquals(0, r.invocationCount);
1669 <        checkCompletedNormally(g, v1);
1669 >        checkCompletedNormally(fFirst ? f : g, v1);
1670      }}
1671  
1672      /**
1673       * applyToEither result completes normally after normal completion
1674       * of either source
1675       */
1676 <    public void testApplyToEither_normalCompletion1() {
1676 >    public void testApplyToEither_normalCompletion() {
1677          for (ExecutionMode m : ExecutionMode.values())
1678 +        for (boolean createIncomplete : new boolean[] { true, false })
1679 +        for (boolean fFirst : new boolean[] { true, false })
1680          for (Integer v1 : new Integer[] { 1, null })
1681          for (Integer v2 : new Integer[] { 2, null })
1682      {
1683          final CompletableFuture<Integer> f = new CompletableFuture<>();
1684          final CompletableFuture<Integer> g = new CompletableFuture<>();
1685 <        final IncFunction r = new IncFunction();
1773 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1685 >        final IncFunction r = new IncFunction(m);
1686  
1687 <        f.complete(v1);
1688 <        checkCompletedNormally(h, inc(v1));
1689 <        g.complete(v2);
1687 >        if (!createIncomplete)
1688 >            if (fFirst) f.complete(v1); else g.complete(v2);
1689 >        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1690 >        if (createIncomplete) {
1691 >            checkIncomplete(h);
1692 >            assertEquals(0, r.invocationCount);
1693 >            if (fFirst) f.complete(v1); else g.complete(v2);
1694 >        }
1695 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1696 >        if (!fFirst) f.complete(v1); else g.complete(v2);
1697  
1698          checkCompletedNormally(f, v1);
1699          checkCompletedNormally(g, v2);
1700 <        checkCompletedNormally(h, inc(v1));
1700 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1701      }}
1702  
1703 <    public void testApplyToEither_normalCompletion2() {
1703 >    public void testApplyToEither_normalCompletionBothAvailable() {
1704          for (ExecutionMode m : ExecutionMode.values())
1705 +        for (boolean fFirst : new boolean[] { true, false })
1706          for (Integer v1 : new Integer[] { 1, null })
1707          for (Integer v2 : new Integer[] { 2, null })
1708      {
1709          final CompletableFuture<Integer> f = new CompletableFuture<>();
1710          final CompletableFuture<Integer> g = new CompletableFuture<>();
1711 <        final IncFunction r = new IncFunction();
1792 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1793 <
1794 <        g.complete(v2);
1795 <        checkCompletedNormally(h, inc(v2));
1796 <        f.complete(v1);
1797 <
1798 <        checkCompletedNormally(f, v1);
1799 <        checkCompletedNormally(g, v2);
1800 <        checkCompletedNormally(h, inc(v2));
1801 <        }}
1711 >        final IncFunction r = new IncFunction(m);
1712  
1713 <    public void testApplyToEither_normalCompletion3() {
1714 <        for (ExecutionMode m : ExecutionMode.values())
1715 <        for (Integer v1 : new Integer[] { 1, null })
1716 <        for (Integer v2 : new Integer[] { 2, null })
1717 <    {
1718 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1719 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1810 <        final IncFunction r = new IncFunction();
1713 >        if (fFirst) {
1714 >            f.complete(v1);
1715 >            g.complete(v2);
1716 >        } else {
1717 >            g.complete(v2);
1718 >            f.complete(v1);
1719 >        }
1720  
1812        f.complete(v1);
1813        g.complete(v2);
1721          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1722  
1723          checkCompletedNormally(f, v1);
# Line 1828 | Line 1735 | public class CompletableFutureTest exten
1735       */
1736      public void testApplyToEither_exceptionalCompletion1() {
1737          for (ExecutionMode m : ExecutionMode.values())
1738 +        for (boolean createIncomplete : new boolean[] { true, false })
1739 +        for (boolean fFirst : new boolean[] { true, false })
1740          for (Integer v1 : new Integer[] { 1, null })
1741      {
1742          final CompletableFuture<Integer> f = new CompletableFuture<>();
1743          final CompletableFuture<Integer> g = new CompletableFuture<>();
1835        final IncFunction r = new IncFunction();
1836        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1744          final CFException ex = new CFException();
1745 +        final IncFunction r = new IncFunction(m);
1746  
1747 <        f.completeExceptionally(ex);
1840 <        checkCompletedWithWrappedCFException(h, ex);
1841 <        g.complete(v1);
1842 <
1843 <        assertEquals(0, r.invocationCount);
1844 <        checkCompletedNormally(g, v1);
1845 <        checkCompletedWithWrappedCFException(f, ex);
1846 <        checkCompletedWithWrappedCFException(h, ex);
1847 <    }}
1848 <
1849 <    public void testApplyToEither_exceptionalCompletion2() {
1850 <        for (ExecutionMode m : ExecutionMode.values())
1851 <        for (Integer v1 : new Integer[] { 1, null })
1852 <    {
1853 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1854 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1855 <        final IncFunction r = new IncFunction();
1747 >        if (!createIncomplete) (fFirst ? f : g).completeExceptionally(ex);
1748          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1749 <        final CFException ex = new CFException();
1749 >        if (createIncomplete) {
1750 >            checkIncomplete(h);
1751 >            assertEquals(0, r.invocationCount);
1752 >            (fFirst ? f : g).completeExceptionally(ex);
1753 >        }
1754  
1859        g.completeExceptionally(ex);
1755          checkCompletedWithWrappedCFException(h, ex);
1756 <        f.complete(v1);
1756 >        (!fFirst ? f : g).complete(v1);
1757  
1758          assertEquals(0, r.invocationCount);
1759 <        checkCompletedNormally(f, v1);
1760 <        checkCompletedWithWrappedCFException(g, ex);
1759 >        checkCompletedNormally(!fFirst ? f : g, v1);
1760 >        checkCompletedWithWrappedCFException(fFirst ? f : g, ex);
1761          checkCompletedWithWrappedCFException(h, ex);
1762      }}
1763  
1764 <    public void testApplyToEither_exceptionalCompletion3() {
1764 >    public void testApplyToEither_exceptionalCompletion2() {
1765          for (ExecutionMode m : ExecutionMode.values())
1766 +        for (boolean reverseArgs : new boolean[] { true, false })
1767 +        for (boolean fFirst : new boolean[] { true, false })
1768          for (Integer v1 : new Integer[] { 1, null })
1769      {
1770          final CompletableFuture<Integer> f = new CompletableFuture<>();
1771          final CompletableFuture<Integer> g = new CompletableFuture<>();
1772 <        final IncFunction r = new IncFunction();
1772 >        final IncFunction r1 = new IncFunction(m);
1773 >        final IncFunction r2 = new IncFunction(m);
1774          final CFException ex = new CFException();
1775 <
1776 <        g.completeExceptionally(ex);
1777 <        f.complete(v1);
1778 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1775 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1776 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1777 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1778 >        if (fFirst) {
1779 >            f.complete(v1);
1780 >            g.completeExceptionally(ex);
1781 >        } else {
1782 >            g.completeExceptionally(ex);
1783 >            f.complete(v1);
1784 >        }
1785 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1786  
1787          // unspecified behavior
1883        Integer v;
1788          try {
1789 <            assertEquals(inc(v1), h.join());
1790 <            assertEquals(1, r.invocationCount);
1789 >            assertEquals(inc(v1), h1.join());
1790 >            assertEquals(1, r1.invocationCount);
1791          } catch (CompletionException ok) {
1792 <            checkCompletedWithWrappedCFException(h, ex);
1793 <            assertEquals(0, r.invocationCount);
1792 >            checkCompletedWithWrappedCFException(h1, ex);
1793 >            assertEquals(0, r1.invocationCount);
1794          }
1795  
1892        checkCompletedWithWrappedCFException(g, ex);
1893        checkCompletedNormally(f, v1);
1894    }}
1895
1896    public void testApplyToEither_exceptionalCompletion4() {
1897        for (ExecutionMode m : ExecutionMode.values())
1898        for (Integer v1 : new Integer[] { 1, null })
1899    {
1900        final CompletableFuture<Integer> f = new CompletableFuture<>();
1901        final CompletableFuture<Integer> g = new CompletableFuture<>();
1902        final IncFunction r = new IncFunction();
1903        final CFException ex = new CFException();
1904
1905        f.completeExceptionally(ex);
1906        g.complete(v1);
1907        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1908
1909        // unspecified behavior
1910        Integer v;
1796          try {
1797 <            assertEquals(inc(v1), h.join());
1798 <            assertEquals(1, r.invocationCount);
1797 >            assertEquals(inc(v1), h2.join());
1798 >            assertEquals(1, r2.invocationCount);
1799          } catch (CompletionException ok) {
1800 <            checkCompletedWithWrappedCFException(h, ex);
1801 <            assertEquals(0, r.invocationCount);
1800 >            checkCompletedWithWrappedCFException(h2, ex);
1801 >            assertEquals(0, r2.invocationCount);
1802          }
1803  
1804 <        checkCompletedWithWrappedCFException(f, ex);
1805 <        checkCompletedNormally(g, v1);
1804 >        checkCompletedWithWrappedCFException(g, ex);
1805 >        checkCompletedNormally(f, v1);
1806      }}
1807  
1808      /**
# Line 1930 | Line 1815 | public class CompletableFutureTest exten
1815      {
1816          final CompletableFuture<Integer> f = new CompletableFuture<>();
1817          final CompletableFuture<Integer> g = new CompletableFuture<>();
1818 <        final FailingFunction r = new FailingFunction();
1818 >        final FailingFunction r = new FailingFunction(m);
1819          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1820  
1821          f.complete(v1);
# Line 1947 | Line 1832 | public class CompletableFutureTest exten
1832      {
1833          final CompletableFuture<Integer> f = new CompletableFuture<>();
1834          final CompletableFuture<Integer> g = new CompletableFuture<>();
1835 <        final FailingFunction r = new FailingFunction();
1835 >        final FailingFunction r = new FailingFunction(m);
1836          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1837  
1838          g.complete(v2);
# Line 1963 | Line 1848 | public class CompletableFutureTest exten
1848      public void testApplyToEither_sourceCancelled1() {
1849          for (ExecutionMode m : ExecutionMode.values())
1850          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1851 +        for (boolean createIncomplete : new boolean[] { true, false })
1852 +        for (boolean fFirst : new boolean[] { true, false })
1853          for (Integer v1 : new Integer[] { 1, null })
1854      {
1855          final CompletableFuture<Integer> f = new CompletableFuture<>();
1856          final CompletableFuture<Integer> g = new CompletableFuture<>();
1857 <        final IncFunction r = new IncFunction();
1971 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1972 <
1973 <        assertTrue(f.cancel(mayInterruptIfRunning));
1974 <        checkCompletedWithWrappedCancellationException(h);
1975 <        g.complete(v1);
1976 <
1977 <        checkCancelled(f);
1978 <        assertEquals(0, r.invocationCount);
1979 <        checkCompletedNormally(g, v1);
1980 <        checkCompletedWithWrappedCancellationException(h);
1981 <    }}
1857 >        final IncFunction r = new IncFunction(m);
1858  
1859 <    public void testApplyToEither_sourceCancelled2() {
1984 <        for (ExecutionMode m : ExecutionMode.values())
1985 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1986 <        for (Integer v1 : new Integer[] { 1, null })
1987 <    {
1988 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1989 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1990 <        final IncFunction r = new IncFunction();
1859 >        if (!createIncomplete) assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1860          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1861 +        if (createIncomplete) {
1862 +            checkIncomplete(h);
1863 +            assertEquals(0, r.invocationCount);
1864 +            assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1865 +        }
1866  
1993        assertTrue(g.cancel(mayInterruptIfRunning));
1867          checkCompletedWithWrappedCancellationException(h);
1868 <        f.complete(v1);
1868 >        (!fFirst ? f : g).complete(v1);
1869  
1997        checkCancelled(g);
1870          assertEquals(0, r.invocationCount);
1871 <        checkCompletedNormally(f, v1);
1871 >        checkCompletedNormally(!fFirst ? f : g, v1);
1872 >        checkCancelled(fFirst ? f : g);
1873          checkCompletedWithWrappedCancellationException(h);
1874      }}
1875  
1876 <    public void testApplyToEither_sourceCancelled3() {
1876 >    public void testApplyToEither_sourceCancelled2() {
1877          for (ExecutionMode m : ExecutionMode.values())
1878          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1879 +        for (boolean reverseArgs : new boolean[] { true, false })
1880 +        for (boolean fFirst : new boolean[] { true, false })
1881          for (Integer v1 : new Integer[] { 1, null })
1882      {
1883          final CompletableFuture<Integer> f = new CompletableFuture<>();
1884          final CompletableFuture<Integer> g = new CompletableFuture<>();
1885 <        final IncFunction r = new IncFunction();
1885 >        final IncFunction r1 = new IncFunction(m);
1886 >        final IncFunction r2 = new IncFunction(m);
1887 >        final CFException ex = new CFException();
1888 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1889 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1890  
1891 <        assertTrue(g.cancel(mayInterruptIfRunning));
1892 <        f.complete(v1);
1893 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1891 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1892 >        if (fFirst) {
1893 >            f.complete(v1);
1894 >            assertTrue(g.cancel(mayInterruptIfRunning));
1895 >        } else {
1896 >            assertTrue(g.cancel(mayInterruptIfRunning));
1897 >            f.complete(v1);
1898 >        }
1899 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1900  
1901          // unspecified behavior
2017        Integer v;
1902          try {
1903 <            assertEquals(inc(v1), h.join());
1904 <            assertEquals(1, r.invocationCount);
1903 >            assertEquals(inc(v1), h1.join());
1904 >            assertEquals(1, r1.invocationCount);
1905          } catch (CompletionException ok) {
1906 <            checkCompletedWithWrappedCancellationException(h);
1907 <            assertEquals(0, r.invocationCount);
1906 >            checkCompletedWithWrappedCancellationException(h1);
1907 >            assertEquals(0, r1.invocationCount);
1908          }
1909  
2026        checkCancelled(g);
2027        checkCompletedNormally(f, v1);
2028    }}
2029
2030    public void testApplyToEither_sourceCancelled4() {
2031        for (ExecutionMode m : ExecutionMode.values())
2032        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2033        for (Integer v1 : new Integer[] { 1, null })
2034    {
2035        final CompletableFuture<Integer> f = new CompletableFuture<>();
2036        final CompletableFuture<Integer> g = new CompletableFuture<>();
2037        final IncFunction r = new IncFunction();
2038
2039        assertTrue(f.cancel(mayInterruptIfRunning));
2040        g.complete(v1);
2041        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2042
2043        // unspecified behavior
2044        Integer v;
1910          try {
1911 <            assertEquals(inc(v1), h.join());
1912 <            assertEquals(1, r.invocationCount);
1911 >            assertEquals(inc(v1), h2.join());
1912 >            assertEquals(1, r2.invocationCount);
1913          } catch (CompletionException ok) {
1914 <            checkCompletedWithWrappedCancellationException(h);
1915 <            assertEquals(0, r.invocationCount);
1914 >            checkCompletedWithWrappedCancellationException(h2);
1915 >            assertEquals(0, r2.invocationCount);
1916          }
1917  
1918 <        checkCancelled(f);
1919 <        checkCompletedNormally(g, v1);
1918 >        checkCancelled(g);
1919 >        checkCompletedNormally(f, v1);
1920      }}
1921  
1922      /**
# Line 2230 | Line 2095 | public class CompletableFutureTest exten
2095      {
2096          final CompletableFuture<Integer> f = new CompletableFuture<>();
2097          final CompletableFuture<Integer> g = new CompletableFuture<>();
2098 <        final FailingConsumer r = new FailingConsumer();
2098 >        final FailingConsumer r = new FailingConsumer(m);
2099          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2100  
2101          f.complete(v1);
# Line 2247 | Line 2112 | public class CompletableFutureTest exten
2112      {
2113          final CompletableFuture<Integer> f = new CompletableFuture<>();
2114          final CompletableFuture<Integer> g = new CompletableFuture<>();
2115 <        final FailingConsumer r = new FailingConsumer();
2115 >        final FailingConsumer r = new FailingConsumer(m);
2116          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2117  
2118          g.complete(v2);
# Line 2367 | Line 2232 | public class CompletableFutureTest exten
2232      {
2233          final CompletableFuture<Integer> f = new CompletableFuture<>();
2234          final CompletableFuture<Integer> g = new CompletableFuture<>();
2235 <        final Noop r = new Noop();
2235 >        final Noop r = new Noop(m);
2236          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2237  
2238          f.complete(v1);
# Line 2388 | Line 2253 | public class CompletableFutureTest exten
2253      {
2254          final CompletableFuture<Integer> f = new CompletableFuture<>();
2255          final CompletableFuture<Integer> g = new CompletableFuture<>();
2256 <        final Noop r = new Noop();
2256 >        final Noop r = new Noop(m);
2257          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2258  
2259          g.complete(v2);
# Line 2409 | Line 2274 | public class CompletableFutureTest exten
2274      {
2275          final CompletableFuture<Integer> f = new CompletableFuture<>();
2276          final CompletableFuture<Integer> g = new CompletableFuture<>();
2277 <        final Noop r = new Noop();
2277 >        final Noop r = new Noop(m);
2278  
2279          f.complete(v1);
2280          g.complete(v2);
# Line 2431 | Line 2296 | public class CompletableFutureTest exten
2296      {
2297          final CompletableFuture<Integer> f = new CompletableFuture<>();
2298          final CompletableFuture<Integer> g = new CompletableFuture<>();
2299 <        final Noop r = new Noop();
2299 >        final Noop r = new Noop(m);
2300          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2301          final CFException ex = new CFException();
2302  
# Line 2451 | Line 2316 | public class CompletableFutureTest exten
2316      {
2317          final CompletableFuture<Integer> f = new CompletableFuture<>();
2318          final CompletableFuture<Integer> g = new CompletableFuture<>();
2319 <        final Noop r = new Noop();
2319 >        final Noop r = new Noop(m);
2320          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2321          final CFException ex = new CFException();
2322  
# Line 2471 | Line 2336 | public class CompletableFutureTest exten
2336      {
2337          final CompletableFuture<Integer> f = new CompletableFuture<>();
2338          final CompletableFuture<Integer> g = new CompletableFuture<>();
2339 <        final Noop r = new Noop();
2339 >        final Noop r = new Noop(m);
2340          final CFException ex = new CFException();
2341  
2342          g.completeExceptionally(ex);
# Line 2498 | Line 2363 | public class CompletableFutureTest exten
2363      {
2364          final CompletableFuture<Integer> f = new CompletableFuture<>();
2365          final CompletableFuture<Integer> g = new CompletableFuture<>();
2366 <        final Noop r = new Noop();
2366 >        final Noop r = new Noop(m);
2367          final CFException ex = new CFException();
2368  
2369          f.completeExceptionally(ex);
# Line 2529 | Line 2394 | public class CompletableFutureTest exten
2394      {
2395          final CompletableFuture<Integer> f = new CompletableFuture<>();
2396          final CompletableFuture<Integer> g = new CompletableFuture<>();
2397 <        final FailingRunnable r = new FailingRunnable();
2397 >        final FailingRunnable r = new FailingRunnable(m);
2398          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2399  
2400          f.complete(v1);
# Line 2546 | Line 2411 | public class CompletableFutureTest exten
2411      {
2412          final CompletableFuture<Integer> f = new CompletableFuture<>();
2413          final CompletableFuture<Integer> g = new CompletableFuture<>();
2414 <        final FailingRunnable r = new FailingRunnable();
2414 >        final FailingRunnable r = new FailingRunnable(m);
2415          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2416  
2417          g.complete(v2);
# Line 2566 | Line 2431 | public class CompletableFutureTest exten
2431      {
2432          final CompletableFuture<Integer> f = new CompletableFuture<>();
2433          final CompletableFuture<Integer> g = new CompletableFuture<>();
2434 <        final Noop r = new Noop();
2434 >        final Noop r = new Noop(m);
2435          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2436  
2437          assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2586 | Line 2451 | public class CompletableFutureTest exten
2451      {
2452          final CompletableFuture<Integer> f = new CompletableFuture<>();
2453          final CompletableFuture<Integer> g = new CompletableFuture<>();
2454 <        final Noop r = new Noop();
2454 >        final Noop r = new Noop(m);
2455          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2456  
2457          assertTrue(g.cancel(mayInterruptIfRunning));
# Line 2606 | Line 2471 | public class CompletableFutureTest exten
2471      {
2472          final CompletableFuture<Integer> f = new CompletableFuture<>();
2473          final CompletableFuture<Integer> g = new CompletableFuture<>();
2474 <        final Noop r = new Noop();
2474 >        final Noop r = new Noop(m);
2475  
2476          assertTrue(g.cancel(mayInterruptIfRunning));
2477          f.complete(v1);
# Line 2633 | Line 2498 | public class CompletableFutureTest exten
2498      {
2499          final CompletableFuture<Integer> f = new CompletableFuture<>();
2500          final CompletableFuture<Integer> g = new CompletableFuture<>();
2501 <        final Noop r = new Noop();
2501 >        final Noop r = new Noop(m);
2502  
2503          assertTrue(f.cancel(mayInterruptIfRunning));
2504          g.complete(v1);
# Line 2662 | Line 2527 | public class CompletableFutureTest exten
2527          for (Integer v1 : new Integer[] { 1, null })
2528      {
2529          final CompletableFuture<Integer> f = new CompletableFuture<>();
2530 <        final CompletableFutureInc r = new CompletableFutureInc();
2530 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2531          if (!createIncomplete) f.complete(v1);
2532 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2532 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2533          if (createIncomplete) f.complete(v1);
2534  
2535          checkCompletedNormally(g, inc(v1));
# Line 2681 | Line 2546 | public class CompletableFutureTest exten
2546          for (boolean createIncomplete : new boolean[] { true, false })
2547      {
2548          final CFException ex = new CFException();
2549 <        final CompletableFutureInc r = new CompletableFutureInc();
2549 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2550          final CompletableFuture<Integer> f = new CompletableFuture<>();
2551          if (!createIncomplete) f.completeExceptionally(ex);
2552 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2552 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2553          if (createIncomplete) f.completeExceptionally(ex);
2554  
2555          checkCompletedWithWrappedCFException(g, ex);
# Line 2702 | Line 2567 | public class CompletableFutureTest exten
2567      {
2568          final CompletableFuture<Integer> f = new CompletableFuture<>();
2569          final FailingCompletableFutureFunction r
2570 <            = new FailingCompletableFutureFunction();
2570 >            = new FailingCompletableFutureFunction(m);
2571          if (!createIncomplete) f.complete(v1);
2572 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2572 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2573          if (createIncomplete) f.complete(v1);
2574  
2575          checkCompletedWithWrappedCFException(g);
# Line 2720 | Line 2585 | public class CompletableFutureTest exten
2585          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2586      {
2587          final CompletableFuture<Integer> f = new CompletableFuture<>();
2588 <        final CompletableFutureInc r = new CompletableFutureInc();
2588 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2589          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2590 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2590 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2591          if (createIncomplete) {
2592              checkIncomplete(g);
2593              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2821 | Line 2686 | public class CompletableFutureTest exten
2686          Runnable[] throwingActions = {
2687              () -> CompletableFuture.supplyAsync(null),
2688              () -> CompletableFuture.supplyAsync(null, exec),
2689 <            () -> CompletableFuture.supplyAsync(supplyOne, null),
2689 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
2690  
2691              () -> CompletableFuture.runAsync(null),
2692              () -> CompletableFuture.runAsync(null, exec),
# Line 2894 | Line 2759 | public class CompletableFutureTest exten
2759  
2760              () -> f.thenCompose(null),
2761              () -> f.thenComposeAsync(null),
2762 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2762 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2763              () -> f.thenComposeAsync(null, exec),
2764  
2765              () -> f.exceptionally(null),

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines