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.57 by jsr166, Mon Jun 2 22:48:50 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 349 | Line 349 | public class CompletableFutureTest exten
349          }
350      }
351      static final class IncFunction implements Function<Integer,Integer> {
352 +        final ExecutionMode m;
353          int invocationCount = 0;
354          Integer value;
355 +        IncFunction(ExecutionMode m) { this.m = m; }
356          public Integer apply(Integer x) {
357 +            m.checkExecutionMode();
358              invocationCount++;
359              return value = inc(x);
360          }
361      }
362      static final class SubtractAction implements BiConsumer<Integer, Integer> {
363 +        final ExecutionMode m;
364          int invocationCount = 0;
365          Integer value;
366          // Check this action was invoked exactly once when result is computed.
367 +        SubtractAction(ExecutionMode m) { this.m = m; }
368          public void accept(Integer x, Integer y) {
369 +            m.checkExecutionMode();
370              invocationCount++;
371              value = subtract(x, y);
372          }
373      }
374      static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
375 +        final ExecutionMode m;
376          int invocationCount = 0;
377          Integer value;
378          // Check this action was invoked exactly once when result is computed.
379 +        SubtractFunction(ExecutionMode m) { this.m = m; }
380          public Integer apply(Integer x, Integer y) {
381 +            m.checkExecutionMode();
382              invocationCount++;
383              return value = subtract(x, y);
384          }
385      }
386      static final class Noop implements Runnable {
387 +        final ExecutionMode m;
388          int invocationCount = 0;
389 +        Noop(ExecutionMode m) { this.m = m; }
390          public void run() {
391 +            m.checkExecutionMode();
392              invocationCount++;
393          }
394      }
395  
396      static final class FailingSupplier implements Supplier<Integer> {
397 +        final ExecutionMode m;
398          int invocationCount = 0;
399 +        FailingSupplier(ExecutionMode m) { this.m = m; }
400          public Integer get() {
401 +            m.checkExecutionMode();
402              invocationCount++;
403              throw new CFException();
404          }
405      }
406      static final class FailingConsumer implements Consumer<Integer> {
407 +        final ExecutionMode m;
408          int invocationCount = 0;
409 +        FailingConsumer(ExecutionMode m) { this.m = m; }
410          public void accept(Integer x) {
411 +            m.checkExecutionMode();
412              invocationCount++;
413              throw new CFException();
414          }
415      }
416      static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
417 +        final ExecutionMode m;
418          int invocationCount = 0;
419 +        FailingBiConsumer(ExecutionMode m) { this.m = m; }
420          public void accept(Integer x, Integer y) {
421 +            m.checkExecutionMode();
422              invocationCount++;
423              throw new CFException();
424          }
425      }
426      static final class FailingFunction implements Function<Integer, Integer> {
427 +        final ExecutionMode m;
428          int invocationCount = 0;
429 +        FailingFunction(ExecutionMode m) { this.m = m; }
430          public Integer apply(Integer x) {
431 +            m.checkExecutionMode();
432              invocationCount++;
433              throw new CFException();
434          }
435      }
436      static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
437 +        final ExecutionMode m;
438          int invocationCount = 0;
439 +        FailingBiFunction(ExecutionMode m) { this.m = m; }
440          public Integer apply(Integer x, Integer y) {
441 +            m.checkExecutionMode();
442              invocationCount++;
443              throw new CFException();
444          }
445      }
446      static final class FailingRunnable implements Runnable {
447 +        final ExecutionMode m;
448          int invocationCount = 0;
449 +        FailingRunnable(ExecutionMode m) { this.m = m; }
450          public void run() {
451 +            m.checkExecutionMode();
452              invocationCount++;
453              throw new CFException();
454          }
# Line 426 | Line 456 | public class CompletableFutureTest exten
456  
457      static final class CompletableFutureInc
458          implements Function<Integer, CompletableFuture<Integer>> {
459 +        final ExecutionMode m;
460          int invocationCount = 0;
461 +        CompletableFutureInc(ExecutionMode m) { this.m = m; }
462          public CompletableFuture<Integer> apply(Integer x) {
463 +            m.checkExecutionMode();
464              invocationCount++;
465              CompletableFuture<Integer> f = new CompletableFuture<>();
466              f.complete(inc(x));
# Line 437 | Line 470 | public class CompletableFutureTest exten
470  
471      static final class FailingCompletableFutureFunction
472          implements Function<Integer, CompletableFuture<Integer>> {
473 +        final ExecutionMode m;
474          int invocationCount = 0;
475 +        FailingCompletableFutureFunction(ExecutionMode m) { this.m = m; }
476          public CompletableFuture<Integer> apply(Integer x) {
477 +            m.checkExecutionMode();
478              invocationCount++;
479              throw new CFException();
480          }
# Line 446 | Line 482 | public class CompletableFutureTest exten
482  
483      // Used for explicit executor tests
484      static final class ThreadExecutor implements Executor {
485 <        AtomicInteger count = new AtomicInteger(0);
485 >        final AtomicInteger count = new AtomicInteger(0);
486 >        static final ThreadGroup tg = new ThreadGroup("ThreadExecutor");
487 >        static boolean startedCurrentThread() {
488 >            return Thread.currentThread().getThreadGroup() == tg;
489 >        }
490  
491          public void execute(Runnable r) {
492              count.getAndIncrement();
493 <            new Thread(r).start();
493 >            new Thread(tg, r).start();
494          }
495      }
496  
# Line 463 | Line 503 | public class CompletableFutureTest exten
503              public void checkExecutionMode() {
504                  assertNull(ForkJoinTask.getPool());
505              }
506 +            public CompletableFuture<Void> runAsync(Runnable a) {
507 +                throw new UnsupportedOperationException();
508 +            }
509              public <T> CompletableFuture<Void> thenRun
510                  (CompletableFuture<T> f, Runnable a) {
511                  return f.thenRun(a);
# Line 531 | Line 574 | public class CompletableFutureTest exten
574                  assertSame(ForkJoinPool.commonPool(),
575                             ForkJoinTask.getPool());
576              }
577 +            public CompletableFuture<Void> runAsync(Runnable a) {
578 +                return CompletableFuture.runAsync(a);
579 +            }
580              public <T> CompletableFuture<Void> thenRun
581                  (CompletableFuture<T> f, Runnable a) {
582                  return f.thenRunAsync(a);
# Line 596 | Line 642 | public class CompletableFutureTest exten
642  
643          EXECUTOR {
644              public void checkExecutionMode() {
645 <                //TODO
645 >                assertTrue(ThreadExecutor.startedCurrentThread());
646 >            }
647 >            public CompletableFuture<Void> runAsync(Runnable a) {
648 >                return CompletableFuture.runAsync(a, new ThreadExecutor());
649              }
650              public <T> CompletableFuture<Void> thenRun
651                  (CompletableFuture<T> f, Runnable a) {
# Line 662 | Line 711 | public class CompletableFutureTest exten
711          };
712  
713          public abstract void checkExecutionMode();
714 +        public abstract CompletableFuture<Void> runAsync(Runnable a);
715          public abstract <T> CompletableFuture<Void> thenRun
716              (CompletableFuture<T> f, Runnable a);
717          public abstract <T> CompletableFuture<Void> thenAccept
# Line 740 | Line 790 | public class CompletableFutureTest exten
790          if (!createIncomplete) f.completeExceptionally(ex);
791          final CompletableFuture<Integer> g = f.exceptionally
792              ((Throwable t) -> {
793 +                ExecutionMode.DEFAULT.checkExecutionMode();
794                  threadAssertSame(t, ex);
795                  a.getAndIncrement();
796                  return v1;
# Line 761 | Line 812 | public class CompletableFutureTest exten
812          if (!createIncomplete) f.completeExceptionally(ex1);
813          final CompletableFuture<Integer> g = f.exceptionally
814              ((Throwable t) -> {
815 +                ExecutionMode.DEFAULT.checkExecutionMode();
816                  threadAssertSame(t, ex1);
817                  a.getAndIncrement();
818                  throw ex2;
# Line 786 | Line 838 | public class CompletableFutureTest exten
838          final CompletableFuture<Integer> g = m.handle
839              (f,
840               (Integer x, Throwable t) -> {
841 +                m.checkExecutionMode();
842                  threadAssertSame(x, v1);
843                  threadAssertNull(t);
844                  a.getAndIncrement();
# Line 814 | Line 867 | public class CompletableFutureTest exten
867          final CompletableFuture<Integer> g = m.handle
868              (f,
869               (Integer x, Throwable t) -> {
870 +                m.checkExecutionMode();
871                  threadAssertNull(x);
872                  threadAssertSame(t, ex);
873                  a.getAndIncrement();
# Line 842 | Line 896 | public class CompletableFutureTest exten
896          final CompletableFuture<Integer> g = m.handle
897              (f,
898               (Integer x, Throwable t) -> {
899 +                m.checkExecutionMode();
900                  threadAssertNull(x);
901                  threadAssertTrue(t instanceof CancellationException);
902                  a.getAndIncrement();
# Line 869 | Line 924 | public class CompletableFutureTest exten
924          final CompletableFuture<Integer> g = m.handle
925              (f,
926               (Integer x, Throwable t) -> {
927 +                m.checkExecutionMode();
928                  threadAssertNull(x);
929                  threadAssertSame(ex1, t);
930                  a.getAndIncrement();
# Line 893 | Line 949 | public class CompletableFutureTest exten
949          final CompletableFuture<Integer> g = m.handle
950              (f,
951               (Integer x, Throwable t) -> {
952 +                m.checkExecutionMode();
953                  threadAssertSame(x, v1);
954                  threadAssertNull(t);
955                  a.getAndIncrement();
# Line 908 | Line 965 | public class CompletableFutureTest exten
965      /**
966       * runAsync completes after running Runnable
967       */
968 <    public void testRunAsync() {
969 <        Noop r = new Noop();
970 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
968 >    public void testRunAsync_normalCompletion() {
969 >        ExecutionMode[] executionModes = {
970 >            ExecutionMode.ASYNC,
971 >            ExecutionMode.EXECUTOR,
972 >        };
973 >        for (ExecutionMode m : executionModes)
974 >    {
975 >        final Noop r = new Noop(m);
976 >        final CompletableFuture<Void> f = m.runAsync(r);
977          assertNull(f.join());
915 –        assertEquals(1, r.invocationCount);
978          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());
979          assertEquals(1, r.invocationCount);
980 <        checkCompletedNormally(f, null);
929 <        assertEquals(1, exec.count.get());
930 <    }
980 >    }}
981  
982      /**
983       * failing runAsync completes exceptionally after running Runnable
984       */
985 <    public void testRunAsync3() {
986 <        FailingRunnable r = new FailingRunnable();
987 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
985 >    public void testRunAsync_exceptionalCompletion() {
986 >        ExecutionMode[] executionModes = {
987 >            ExecutionMode.ASYNC,
988 >            ExecutionMode.EXECUTOR,
989 >        };
990 >        for (ExecutionMode m : executionModes)
991 >    {
992 >        final FailingRunnable r = new FailingRunnable(m);
993 >        final CompletableFuture<Void> f = m.runAsync(r);
994          checkCompletedWithWrappedCFException(f);
995          assertEquals(1, r.invocationCount);
996 <    }
996 >    }}
997  
998      /**
999       * supplyAsync completes with result of supplier
# Line 963 | Line 1019 | public class CompletableFutureTest exten
1019       * Failing supplyAsync completes exceptionally
1020       */
1021      public void testSupplyAsync3() {
1022 <        FailingSupplier r = new FailingSupplier();
1022 >        FailingSupplier r = new FailingSupplier(ExecutionMode.ASYNC);
1023          CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
1024          checkCompletedWithWrappedCFException(f);
1025          assertEquals(1, r.invocationCount);
# Line 980 | Line 1036 | public class CompletableFutureTest exten
1036          for (Integer v1 : new Integer[] { 1, null })
1037      {
1038          final CompletableFuture<Integer> f = new CompletableFuture<>();
1039 <        final Noop r = new Noop();
1039 >        final Noop r = new Noop(m);
1040          if (!createIncomplete) f.complete(v1);
1041          final CompletableFuture<Void> g = m.thenRun(f, r);
1042          if (createIncomplete) {
# Line 1003 | Line 1059 | public class CompletableFutureTest exten
1059      {
1060          final CFException ex = new CFException();
1061          final CompletableFuture<Integer> f = new CompletableFuture<>();
1062 <        final Noop r = new Noop();
1062 >        final Noop r = new Noop(m);
1063          if (!createIncomplete) f.completeExceptionally(ex);
1064          final CompletableFuture<Void> g = m.thenRun(f, r);
1065          if (createIncomplete) {
# Line 1025 | Line 1081 | public class CompletableFutureTest exten
1081          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1082      {
1083          final CompletableFuture<Integer> f = new CompletableFuture<>();
1084 <        final Noop r = new Noop();
1084 >        final Noop r = new Noop(m);
1085          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1086 <        final CompletableFuture<Void> g = f.thenRun(r);
1086 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1087          if (createIncomplete) {
1088              checkIncomplete(g);
1089              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1047 | Line 1103 | public class CompletableFutureTest exten
1103          for (Integer v1 : new Integer[] { 1, null })
1104      {
1105          final CompletableFuture<Integer> f = new CompletableFuture<>();
1106 <        final FailingRunnable r = new FailingRunnable();
1106 >        final FailingRunnable r = new FailingRunnable(m);
1107          if (!createIncomplete) f.complete(v1);
1108 <        final CompletableFuture<Void> g = f.thenRun(r);
1108 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1109          if (createIncomplete) {
1110              checkIncomplete(g);
1111              f.complete(v1);
# Line 1068 | Line 1124 | public class CompletableFutureTest exten
1124          for (Integer v1 : new Integer[] { 1, null })
1125      {
1126          final CompletableFuture<Integer> f = new CompletableFuture<>();
1127 <        final IncFunction r = new IncFunction();
1127 >        final IncFunction r = new IncFunction(m);
1128          if (!createIncomplete) f.complete(v1);
1129          final CompletableFuture<Integer> g = m.thenApply(f, r);
1130          if (createIncomplete) {
# Line 1091 | Line 1147 | public class CompletableFutureTest exten
1147      {
1148          final CFException ex = new CFException();
1149          final CompletableFuture<Integer> f = new CompletableFuture<>();
1150 <        final IncFunction r = new IncFunction();
1150 >        final IncFunction r = new IncFunction(m);
1151          if (!createIncomplete) f.completeExceptionally(ex);
1152          final CompletableFuture<Integer> g = m.thenApply(f, r);
1153          if (createIncomplete) {
# Line 1113 | Line 1169 | public class CompletableFutureTest exten
1169          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1170      {
1171          final CompletableFuture<Integer> f = new CompletableFuture<>();
1172 <        final IncFunction r = new IncFunction();
1172 >        final IncFunction r = new IncFunction(m);
1173          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1174 <        final CompletableFuture<Integer> g = f.thenApply(r);
1174 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1175          if (createIncomplete) {
1176              checkIncomplete(g);
1177              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1135 | Line 1191 | public class CompletableFutureTest exten
1191          for (Integer v1 : new Integer[] { 1, null })
1192      {
1193          final CompletableFuture<Integer> f = new CompletableFuture<>();
1194 <        final FailingFunction r = new FailingFunction();
1194 >        final FailingFunction r = new FailingFunction(m);
1195          if (!createIncomplete) f.complete(v1);
1196 <        final CompletableFuture<Integer> g = f.thenApply(r);
1196 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1197          if (createIncomplete) {
1198              checkIncomplete(g);
1199              f.complete(v1);
# Line 1202 | Line 1258 | public class CompletableFutureTest exten
1258          for (Integer v1 : new Integer[] { 1, null })
1259      {
1260          final CompletableFuture<Integer> f = new CompletableFuture<>();
1261 <        final FailingConsumer r = new FailingConsumer();
1261 >        final FailingConsumer r = new FailingConsumer(m);
1262          if (!createIncomplete) f.complete(v1);
1263 <        final CompletableFuture<Void> g = f.thenAccept(r);
1263 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1264          if (createIncomplete) {
1265              checkIncomplete(g);
1266              f.complete(v1);
# Line 1225 | Line 1281 | public class CompletableFutureTest exten
1281          final CompletableFuture<Integer> f = new CompletableFuture<>();
1282          final IncAction r = new IncAction();
1283          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1284 <        final CompletableFuture<Void> g = f.thenAccept(r);
1284 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1285          if (createIncomplete) {
1286              checkIncomplete(g);
1287              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1249 | Line 1305 | public class CompletableFutureTest exten
1305      {
1306          final CompletableFuture<Integer> f = new CompletableFuture<>();
1307          final CompletableFuture<Integer> g = new CompletableFuture<>();
1308 <        final SubtractFunction r = new SubtractFunction();
1308 >        final SubtractFunction r = new SubtractFunction(m);
1309  
1310          if (fFirst) f.complete(v1); else g.complete(v2);
1311          if (!createIncomplete)
# Line 1280 | Line 1336 | public class CompletableFutureTest exten
1336          final CompletableFuture<Integer> f = new CompletableFuture<>();
1337          final CompletableFuture<Integer> g = new CompletableFuture<>();
1338          final CFException ex = new CFException();
1339 <        final SubtractFunction r = new SubtractFunction();
1339 >        final SubtractFunction r = new SubtractFunction(m);
1340  
1341          (fFirst ? f : g).complete(v1);
1342          if (!createIncomplete)
# Line 1308 | Line 1364 | public class CompletableFutureTest exten
1364      {
1365          final CompletableFuture<Integer> f = new CompletableFuture<>();
1366          final CompletableFuture<Integer> g = new CompletableFuture<>();
1367 <        final FailingBiFunction r = new FailingBiFunction();
1367 >        final FailingBiFunction r = new FailingBiFunction(m);
1368          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1369  
1370          if (fFirst) {
# Line 1336 | Line 1392 | public class CompletableFutureTest exten
1392      {
1393          final CompletableFuture<Integer> f = new CompletableFuture<>();
1394          final CompletableFuture<Integer> g = new CompletableFuture<>();
1395 <        final SubtractFunction r = new SubtractFunction();
1395 >        final SubtractFunction r = new SubtractFunction(m);
1396  
1397          (fFirst ? f : g).complete(v1);
1398          if (!createIncomplete)
# Line 1366 | Line 1422 | public class CompletableFutureTest exten
1422      {
1423          final CompletableFuture<Integer> f = new CompletableFuture<>();
1424          final CompletableFuture<Integer> g = new CompletableFuture<>();
1425 <        final SubtractAction r = new SubtractAction();
1425 >        final SubtractAction r = new SubtractAction(m);
1426  
1427          if (fFirst) f.complete(v1); else g.complete(v2);
1428          if (!createIncomplete)
# Line 1397 | Line 1453 | public class CompletableFutureTest exten
1453          final CompletableFuture<Integer> f = new CompletableFuture<>();
1454          final CompletableFuture<Integer> g = new CompletableFuture<>();
1455          final CFException ex = new CFException();
1456 <        final SubtractAction r = new SubtractAction();
1456 >        final SubtractAction r = new SubtractAction(m);
1457  
1458          (fFirst ? f : g).complete(v1);
1459          if (!createIncomplete)
# Line 1425 | Line 1481 | public class CompletableFutureTest exten
1481      {
1482          final CompletableFuture<Integer> f = new CompletableFuture<>();
1483          final CompletableFuture<Integer> g = new CompletableFuture<>();
1484 <        final FailingBiConsumer r = new FailingBiConsumer();
1484 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1485          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1486  
1487          if (fFirst) {
# Line 1453 | Line 1509 | public class CompletableFutureTest exten
1509      {
1510          final CompletableFuture<Integer> f = new CompletableFuture<>();
1511          final CompletableFuture<Integer> g = new CompletableFuture<>();
1512 <        final SubtractAction r = new SubtractAction();
1512 >        final SubtractAction r = new SubtractAction(m);
1513  
1514          (fFirst ? f : g).complete(v1);
1515          if (!createIncomplete)
# Line 1474 | Line 1530 | public class CompletableFutureTest exten
1530       * runAfterBoth result completes normally after normal
1531       * completion of sources
1532       */
1533 <    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() {
1533 >    public void testRunAfterBoth_normalCompletion() {
1534          for (ExecutionMode m : ExecutionMode.values())
1535 +        for (boolean createIncomplete : new boolean[] { true, false })
1536 +        for (boolean fFirst : new boolean[] { true, false })
1537          for (Integer v1 : new Integer[] { 1, null })
1538          for (Integer v2 : new Integer[] { 2, null })
1539      {
1540          final CompletableFuture<Integer> f = new CompletableFuture<>();
1541          final CompletableFuture<Integer> g = new CompletableFuture<>();
1542 <        final Noop r = new Noop();
1542 >        final Noop r = new Noop(m);
1543  
1544 <        f.complete(v1);
1545 <        g.complete(v2);
1544 >        if (fFirst) f.complete(v1); else g.complete(v2);
1545 >        if (!createIncomplete)
1546 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1547          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1548 +        if (createIncomplete) {
1549 +            checkIncomplete(h);
1550 +            assertEquals(0, r.invocationCount);
1551 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1552 +        }
1553  
1554          checkCompletedNormally(h, null);
1555          assertEquals(1, r.invocationCount);
# Line 1558 | Line 1561 | public class CompletableFutureTest exten
1561       * runAfterBoth result completes exceptionally after exceptional
1562       * completion of either source
1563       */
1564 <    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() {
1564 >    public void testRunAfterBoth_exceptionalCompletion() {
1565          for (ExecutionMode m : ExecutionMode.values())
1566 +        for (boolean createIncomplete : new boolean[] { true, false })
1567 +        for (boolean fFirst : new boolean[] { true, false })
1568          for (Integer v1 : new Integer[] { 1, null })
1569      {
1570          final CompletableFuture<Integer> f = new CompletableFuture<>();
1571          final CompletableFuture<Integer> g = new CompletableFuture<>();
1626 –        final Noop r = new Noop();
1572          final CFException ex = new CFException();
1573 +        final Noop r = new Noop(m);
1574  
1575 <        f.completeExceptionally(ex);
1576 <        g.complete(v1);
1575 >        (fFirst ? f : g).complete(v1);
1576 >        if (!createIncomplete)
1577 >            (!fFirst ? f : g).completeExceptionally(ex);
1578          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1579 +        if (createIncomplete) {
1580 +            checkIncomplete(h);
1581 +            (!fFirst ? f : g).completeExceptionally(ex);
1582 +        }
1583  
1584          checkCompletedWithWrappedCFException(h, ex);
1634 –        checkCompletedWithWrappedCFException(f, ex);
1585          assertEquals(0, r.invocationCount);
1586 <        checkCompletedNormally(g, v1);
1586 >        checkCompletedNormally(fFirst ? f : g, v1);
1587 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1588      }}
1589  
1590      /**
1591       * runAfterBoth result completes exceptionally if action does
1592       */
1593 <    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() {
1593 >    public void testRunAfterBoth_actionFailed() {
1594          for (ExecutionMode m : ExecutionMode.values())
1595 +        for (boolean fFirst : new boolean[] { true, false })
1596          for (Integer v1 : new Integer[] { 1, null })
1597          for (Integer v2 : new Integer[] { 2, null })
1598      {
1599          final CompletableFuture<Integer> f = new CompletableFuture<>();
1600          final CompletableFuture<Integer> g = new CompletableFuture<>();
1601 <        final FailingRunnable r = new FailingRunnable();
1669 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1601 >        final FailingRunnable r = new FailingRunnable(m);
1602  
1603 <        g.complete(v2);
1604 <        checkIncomplete(h);
1605 <        f.complete(v1);
1603 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r);
1604 >        if (fFirst) {
1605 >            f.complete(v1);
1606 >            g.complete(v2);
1607 >        } else {
1608 >            g.complete(v2);
1609 >            f.complete(v1);
1610 >        }
1611 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r);
1612  
1613 <        checkCompletedWithWrappedCFException(h);
1613 >        checkCompletedWithWrappedCFException(h1);
1614 >        checkCompletedWithWrappedCFException(h2);
1615          checkCompletedNormally(f, v1);
1616          checkCompletedNormally(g, v2);
1617      }}
# Line 1680 | Line 1619 | public class CompletableFutureTest exten
1619      /**
1620       * runAfterBoth result completes exceptionally if either source cancelled
1621       */
1622 <    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() {
1622 >    public void testRunAfterBoth_sourceCancelled() {
1623          for (ExecutionMode m : ExecutionMode.values())
1624          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1625 +        for (boolean createIncomplete : new boolean[] { true, false })
1626 +        for (boolean fFirst : new boolean[] { true, false })
1627          for (Integer v1 : new Integer[] { 1, null })
1628      {
1629          final CompletableFuture<Integer> f = new CompletableFuture<>();
1630          final CompletableFuture<Integer> g = new CompletableFuture<>();
1631 <        final Noop r = new Noop();
1631 >        final Noop r = new Noop(m);
1632  
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 –    }}
1741 –
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();
1633  
1634 <        assertTrue(f.cancel(mayInterruptIfRunning));
1635 <        g.complete(v1);
1634 >        (fFirst ? f : g).complete(v1);
1635 >        if (!createIncomplete)
1636 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1637          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1638 +        if (createIncomplete) {
1639 +            checkIncomplete(h);
1640 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1641 +        }
1642  
1643          checkCompletedWithWrappedCancellationException(h);
1644 <        checkCancelled(f);
1644 >        checkCancelled(!fFirst ? f : g);
1645          assertEquals(0, r.invocationCount);
1646 <        checkCompletedNormally(g, v1);
1646 >        checkCompletedNormally(fFirst ? f : g, v1);
1647      }}
1648  
1649      /**
1650       * applyToEither result completes normally after normal completion
1651       * of either source
1652       */
1653 <    public void testApplyToEither_normalCompletion1() {
1653 >    public void testApplyToEither_normalCompletion() {
1654          for (ExecutionMode m : ExecutionMode.values())
1655 +        for (boolean createIncomplete : new boolean[] { true, false })
1656 +        for (boolean fFirst : new boolean[] { true, false })
1657          for (Integer v1 : new Integer[] { 1, null })
1658          for (Integer v2 : new Integer[] { 2, null })
1659      {
1660          final CompletableFuture<Integer> f = new CompletableFuture<>();
1661          final CompletableFuture<Integer> g = new CompletableFuture<>();
1662 <        final IncFunction r = new IncFunction();
1773 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1662 >        final IncFunction r = new IncFunction(m);
1663  
1664 <        f.complete(v1);
1665 <        checkCompletedNormally(h, inc(v1));
1666 <        g.complete(v2);
1664 >        if (!createIncomplete)
1665 >            if (fFirst) f.complete(v1); else g.complete(v2);
1666 >        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1667 >        if (createIncomplete) {
1668 >            checkIncomplete(h);
1669 >            assertEquals(0, r.invocationCount);
1670 >            if (fFirst) f.complete(v1); else g.complete(v2);
1671 >        }
1672 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1673 >        if (!fFirst) f.complete(v1); else g.complete(v2);
1674  
1675          checkCompletedNormally(f, v1);
1676          checkCompletedNormally(g, v2);
1677 <        checkCompletedNormally(h, inc(v1));
1677 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1678      }}
1679  
1680 <    public void testApplyToEither_normalCompletion2() {
1680 >    public void testApplyToEither_normalCompletionBothAvailable() {
1681          for (ExecutionMode m : ExecutionMode.values())
1682 +        for (boolean fFirst : new boolean[] { true, false })
1683          for (Integer v1 : new Integer[] { 1, null })
1684          for (Integer v2 : new Integer[] { 2, null })
1685      {
1686          final CompletableFuture<Integer> f = new CompletableFuture<>();
1687          final CompletableFuture<Integer> g = new CompletableFuture<>();
1688 <        final IncFunction r = new IncFunction();
1792 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1688 >        final IncFunction r = new IncFunction(m);
1689  
1690 <        g.complete(v2);
1691 <        checkCompletedNormally(h, inc(v2));
1692 <        f.complete(v1);
1693 <
1694 <        checkCompletedNormally(f, v1);
1695 <        checkCompletedNormally(g, v2);
1696 <        checkCompletedNormally(h, inc(v2));
1801 <        }}
1802 <
1803 <    public void testApplyToEither_normalCompletion3() {
1804 <        for (ExecutionMode m : ExecutionMode.values())
1805 <        for (Integer v1 : new Integer[] { 1, null })
1806 <        for (Integer v2 : new Integer[] { 2, null })
1807 <    {
1808 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1809 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1810 <        final IncFunction r = new IncFunction();
1690 >        if (fFirst) {
1691 >            f.complete(v1);
1692 >            g.complete(v2);
1693 >        } else {
1694 >            g.complete(v2);
1695 >            f.complete(v1);
1696 >        }
1697  
1812 –        f.complete(v1);
1813 –        g.complete(v2);
1698          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1699  
1700          checkCompletedNormally(f, v1);
# Line 1828 | Line 1712 | public class CompletableFutureTest exten
1712       */
1713      public void testApplyToEither_exceptionalCompletion1() {
1714          for (ExecutionMode m : ExecutionMode.values())
1715 +        for (boolean createIncomplete : new boolean[] { true, false })
1716 +        for (boolean fFirst : new boolean[] { true, false })
1717          for (Integer v1 : new Integer[] { 1, null })
1718      {
1719          final CompletableFuture<Integer> f = new CompletableFuture<>();
1720          final CompletableFuture<Integer> g = new CompletableFuture<>();
1835 –        final IncFunction r = new IncFunction();
1836 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1721          final CFException ex = new CFException();
1722 +        final IncFunction r = new IncFunction(m);
1723  
1724 <        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();
1724 >        if (!createIncomplete) (fFirst ? f : g).completeExceptionally(ex);
1725          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1726 <        final CFException ex = new CFException();
1726 >        if (createIncomplete) {
1727 >            checkIncomplete(h);
1728 >            assertEquals(0, r.invocationCount);
1729 >            (fFirst ? f : g).completeExceptionally(ex);
1730 >        }
1731  
1859 –        g.completeExceptionally(ex);
1732          checkCompletedWithWrappedCFException(h, ex);
1733 <        f.complete(v1);
1733 >        (!fFirst ? f : g).complete(v1);
1734  
1735          assertEquals(0, r.invocationCount);
1736 <        checkCompletedNormally(f, v1);
1737 <        checkCompletedWithWrappedCFException(g, ex);
1736 >        checkCompletedNormally(!fFirst ? f : g, v1);
1737 >        checkCompletedWithWrappedCFException(fFirst ? f : g, ex);
1738          checkCompletedWithWrappedCFException(h, ex);
1739      }}
1740  
1741 <    public void testApplyToEither_exceptionalCompletion3() {
1741 >    public void testApplyToEither_exceptionalCompletion2() {
1742          for (ExecutionMode m : ExecutionMode.values())
1743 +        for (boolean reverseArgs : new boolean[] { true, false })
1744 +        for (boolean fFirst : 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 IncFunction r = new IncFunction();
1749 >        final IncFunction r1 = new IncFunction(m);
1750 >        final IncFunction r2 = new IncFunction(m);
1751          final CFException ex = new CFException();
1752 <
1753 <        g.completeExceptionally(ex);
1754 <        f.complete(v1);
1755 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1752 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1753 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1754 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1755 >        if (fFirst) {
1756 >            f.complete(v1);
1757 >            g.completeExceptionally(ex);
1758 >        } else {
1759 >            g.completeExceptionally(ex);
1760 >            f.complete(v1);
1761 >        }
1762 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1763  
1764          // unspecified behavior
1883 –        Integer v;
1765          try {
1766 <            assertEquals(inc(v1), h.join());
1767 <            assertEquals(1, r.invocationCount);
1766 >            assertEquals(inc(v1), h1.join());
1767 >            assertEquals(1, r1.invocationCount);
1768          } catch (CompletionException ok) {
1769 <            checkCompletedWithWrappedCFException(h, ex);
1770 <            assertEquals(0, r.invocationCount);
1769 >            checkCompletedWithWrappedCFException(h1, ex);
1770 >            assertEquals(0, r1.invocationCount);
1771          }
1772  
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;
1773          try {
1774 <            assertEquals(inc(v1), h.join());
1775 <            assertEquals(1, r.invocationCount);
1774 >            assertEquals(inc(v1), h2.join());
1775 >            assertEquals(1, r2.invocationCount);
1776          } catch (CompletionException ok) {
1777 <            checkCompletedWithWrappedCFException(h, ex);
1778 <            assertEquals(0, r.invocationCount);
1777 >            checkCompletedWithWrappedCFException(h2, ex);
1778 >            assertEquals(0, r2.invocationCount);
1779          }
1780  
1781 <        checkCompletedWithWrappedCFException(f, ex);
1782 <        checkCompletedNormally(g, v1);
1781 >        checkCompletedWithWrappedCFException(g, ex);
1782 >        checkCompletedNormally(f, v1);
1783      }}
1784  
1785      /**
# Line 1930 | Line 1792 | public class CompletableFutureTest exten
1792      {
1793          final CompletableFuture<Integer> f = new CompletableFuture<>();
1794          final CompletableFuture<Integer> g = new CompletableFuture<>();
1795 <        final FailingFunction r = new FailingFunction();
1795 >        final FailingFunction r = new FailingFunction(m);
1796          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1797  
1798          f.complete(v1);
# Line 1947 | Line 1809 | public class CompletableFutureTest exten
1809      {
1810          final CompletableFuture<Integer> f = new CompletableFuture<>();
1811          final CompletableFuture<Integer> g = new CompletableFuture<>();
1812 <        final FailingFunction r = new FailingFunction();
1812 >        final FailingFunction r = new FailingFunction(m);
1813          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1814  
1815          g.complete(v2);
# Line 1963 | Line 1825 | public class CompletableFutureTest exten
1825      public void testApplyToEither_sourceCancelled1() {
1826          for (ExecutionMode m : ExecutionMode.values())
1827          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1828 +        for (boolean createIncomplete : new boolean[] { true, false })
1829 +        for (boolean fFirst : new boolean[] { true, false })
1830          for (Integer v1 : new Integer[] { 1, null })
1831      {
1832          final CompletableFuture<Integer> f = new CompletableFuture<>();
1833          final CompletableFuture<Integer> g = new CompletableFuture<>();
1834 <        final IncFunction r = new IncFunction();
1971 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1834 >        final IncFunction r = new IncFunction(m);
1835  
1836 <        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 <    }}
1982 <
1983 <    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();
1836 >        if (!createIncomplete) assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1837          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1838 +        if (createIncomplete) {
1839 +            checkIncomplete(h);
1840 +            assertEquals(0, r.invocationCount);
1841 +            assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1842 +        }
1843  
1993 –        assertTrue(g.cancel(mayInterruptIfRunning));
1844          checkCompletedWithWrappedCancellationException(h);
1845 <        f.complete(v1);
1845 >        (!fFirst ? f : g).complete(v1);
1846  
1997 –        checkCancelled(g);
1847          assertEquals(0, r.invocationCount);
1848 <        checkCompletedNormally(f, v1);
1848 >        checkCompletedNormally(!fFirst ? f : g, v1);
1849 >        checkCancelled(fFirst ? f : g);
1850          checkCompletedWithWrappedCancellationException(h);
1851      }}
1852  
1853 <    public void testApplyToEither_sourceCancelled3() {
1853 >    public void testApplyToEither_sourceCancelled2() {
1854          for (ExecutionMode m : ExecutionMode.values())
1855          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1856 +        for (boolean reverseArgs : new boolean[] { true, false })
1857 +        for (boolean fFirst : new boolean[] { true, false })
1858          for (Integer v1 : new Integer[] { 1, null })
1859      {
1860          final CompletableFuture<Integer> f = new CompletableFuture<>();
1861          final CompletableFuture<Integer> g = new CompletableFuture<>();
1862 <        final IncFunction r = new IncFunction();
1862 >        final IncFunction r1 = new IncFunction(m);
1863 >        final IncFunction r2 = new IncFunction(m);
1864 >        final CFException ex = new CFException();
1865 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1866 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1867  
1868 <        assertTrue(g.cancel(mayInterruptIfRunning));
1869 <        f.complete(v1);
1870 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1868 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1869 >        if (fFirst) {
1870 >            f.complete(v1);
1871 >            assertTrue(g.cancel(mayInterruptIfRunning));
1872 >        } else {
1873 >            assertTrue(g.cancel(mayInterruptIfRunning));
1874 >            f.complete(v1);
1875 >        }
1876 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1877  
1878          // unspecified behavior
2017 –        Integer v;
1879          try {
1880 <            assertEquals(inc(v1), h.join());
1881 <            assertEquals(1, r.invocationCount);
1880 >            assertEquals(inc(v1), h1.join());
1881 >            assertEquals(1, r1.invocationCount);
1882          } catch (CompletionException ok) {
1883 <            checkCompletedWithWrappedCancellationException(h);
1884 <            assertEquals(0, r.invocationCount);
1883 >            checkCompletedWithWrappedCancellationException(h1);
1884 >            assertEquals(0, r1.invocationCount);
1885          }
1886  
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;
1887          try {
1888 <            assertEquals(inc(v1), h.join());
1889 <            assertEquals(1, r.invocationCount);
1888 >            assertEquals(inc(v1), h2.join());
1889 >            assertEquals(1, r2.invocationCount);
1890          } catch (CompletionException ok) {
1891 <            checkCompletedWithWrappedCancellationException(h);
1892 <            assertEquals(0, r.invocationCount);
1891 >            checkCompletedWithWrappedCancellationException(h2);
1892 >            assertEquals(0, r2.invocationCount);
1893          }
1894  
1895 <        checkCancelled(f);
1896 <        checkCompletedNormally(g, v1);
1895 >        checkCancelled(g);
1896 >        checkCompletedNormally(f, v1);
1897      }}
1898  
1899      /**
# Line 2230 | Line 2072 | public class CompletableFutureTest exten
2072      {
2073          final CompletableFuture<Integer> f = new CompletableFuture<>();
2074          final CompletableFuture<Integer> g = new CompletableFuture<>();
2075 <        final FailingConsumer r = new FailingConsumer();
2075 >        final FailingConsumer r = new FailingConsumer(m);
2076          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2077  
2078          f.complete(v1);
# Line 2247 | Line 2089 | public class CompletableFutureTest exten
2089      {
2090          final CompletableFuture<Integer> f = new CompletableFuture<>();
2091          final CompletableFuture<Integer> g = new CompletableFuture<>();
2092 <        final FailingConsumer r = new FailingConsumer();
2092 >        final FailingConsumer r = new FailingConsumer(m);
2093          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2094  
2095          g.complete(v2);
# Line 2367 | Line 2209 | public class CompletableFutureTest exten
2209      {
2210          final CompletableFuture<Integer> f = new CompletableFuture<>();
2211          final CompletableFuture<Integer> g = new CompletableFuture<>();
2212 <        final Noop r = new Noop();
2212 >        final Noop r = new Noop(m);
2213          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2214  
2215          f.complete(v1);
# Line 2388 | Line 2230 | public class CompletableFutureTest exten
2230      {
2231          final CompletableFuture<Integer> f = new CompletableFuture<>();
2232          final CompletableFuture<Integer> g = new CompletableFuture<>();
2233 <        final Noop r = new Noop();
2233 >        final Noop r = new Noop(m);
2234          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2235  
2236          g.complete(v2);
# Line 2409 | Line 2251 | public class CompletableFutureTest exten
2251      {
2252          final CompletableFuture<Integer> f = new CompletableFuture<>();
2253          final CompletableFuture<Integer> g = new CompletableFuture<>();
2254 <        final Noop r = new Noop();
2254 >        final Noop r = new Noop(m);
2255  
2256          f.complete(v1);
2257          g.complete(v2);
# Line 2431 | Line 2273 | public class CompletableFutureTest exten
2273      {
2274          final CompletableFuture<Integer> f = new CompletableFuture<>();
2275          final CompletableFuture<Integer> g = new CompletableFuture<>();
2276 <        final Noop r = new Noop();
2276 >        final Noop r = new Noop(m);
2277          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2278          final CFException ex = new CFException();
2279  
# Line 2451 | Line 2293 | public class CompletableFutureTest exten
2293      {
2294          final CompletableFuture<Integer> f = new CompletableFuture<>();
2295          final CompletableFuture<Integer> g = new CompletableFuture<>();
2296 <        final Noop r = new Noop();
2296 >        final Noop r = new Noop(m);
2297          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2298          final CFException ex = new CFException();
2299  
# Line 2471 | Line 2313 | public class CompletableFutureTest exten
2313      {
2314          final CompletableFuture<Integer> f = new CompletableFuture<>();
2315          final CompletableFuture<Integer> g = new CompletableFuture<>();
2316 <        final Noop r = new Noop();
2316 >        final Noop r = new Noop(m);
2317          final CFException ex = new CFException();
2318  
2319          g.completeExceptionally(ex);
# Line 2498 | Line 2340 | public class CompletableFutureTest exten
2340      {
2341          final CompletableFuture<Integer> f = new CompletableFuture<>();
2342          final CompletableFuture<Integer> g = new CompletableFuture<>();
2343 <        final Noop r = new Noop();
2343 >        final Noop r = new Noop(m);
2344          final CFException ex = new CFException();
2345  
2346          f.completeExceptionally(ex);
# Line 2529 | Line 2371 | public class CompletableFutureTest exten
2371      {
2372          final CompletableFuture<Integer> f = new CompletableFuture<>();
2373          final CompletableFuture<Integer> g = new CompletableFuture<>();
2374 <        final FailingRunnable r = new FailingRunnable();
2374 >        final FailingRunnable r = new FailingRunnable(m);
2375          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2376  
2377          f.complete(v1);
# Line 2546 | Line 2388 | public class CompletableFutureTest exten
2388      {
2389          final CompletableFuture<Integer> f = new CompletableFuture<>();
2390          final CompletableFuture<Integer> g = new CompletableFuture<>();
2391 <        final FailingRunnable r = new FailingRunnable();
2391 >        final FailingRunnable r = new FailingRunnable(m);
2392          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2393  
2394          g.complete(v2);
# Line 2566 | Line 2408 | public class CompletableFutureTest exten
2408      {
2409          final CompletableFuture<Integer> f = new CompletableFuture<>();
2410          final CompletableFuture<Integer> g = new CompletableFuture<>();
2411 <        final Noop r = new Noop();
2411 >        final Noop r = new Noop(m);
2412          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2413  
2414          assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2586 | Line 2428 | public class CompletableFutureTest exten
2428      {
2429          final CompletableFuture<Integer> f = new CompletableFuture<>();
2430          final CompletableFuture<Integer> g = new CompletableFuture<>();
2431 <        final Noop r = new Noop();
2431 >        final Noop r = new Noop(m);
2432          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2433  
2434          assertTrue(g.cancel(mayInterruptIfRunning));
# Line 2606 | Line 2448 | public class CompletableFutureTest exten
2448      {
2449          final CompletableFuture<Integer> f = new CompletableFuture<>();
2450          final CompletableFuture<Integer> g = new CompletableFuture<>();
2451 <        final Noop r = new Noop();
2451 >        final Noop r = new Noop(m);
2452  
2453          assertTrue(g.cancel(mayInterruptIfRunning));
2454          f.complete(v1);
# Line 2633 | Line 2475 | public class CompletableFutureTest exten
2475      {
2476          final CompletableFuture<Integer> f = new CompletableFuture<>();
2477          final CompletableFuture<Integer> g = new CompletableFuture<>();
2478 <        final Noop r = new Noop();
2478 >        final Noop r = new Noop(m);
2479  
2480          assertTrue(f.cancel(mayInterruptIfRunning));
2481          g.complete(v1);
# Line 2662 | Line 2504 | public class CompletableFutureTest exten
2504          for (Integer v1 : new Integer[] { 1, null })
2505      {
2506          final CompletableFuture<Integer> f = new CompletableFuture<>();
2507 <        final CompletableFutureInc r = new CompletableFutureInc();
2507 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2508          if (!createIncomplete) f.complete(v1);
2509 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2509 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2510          if (createIncomplete) f.complete(v1);
2511  
2512          checkCompletedNormally(g, inc(v1));
# Line 2681 | Line 2523 | public class CompletableFutureTest exten
2523          for (boolean createIncomplete : new boolean[] { true, false })
2524      {
2525          final CFException ex = new CFException();
2526 <        final CompletableFutureInc r = new CompletableFutureInc();
2526 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2527          final CompletableFuture<Integer> f = new CompletableFuture<>();
2528          if (!createIncomplete) f.completeExceptionally(ex);
2529 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2529 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2530          if (createIncomplete) f.completeExceptionally(ex);
2531  
2532          checkCompletedWithWrappedCFException(g, ex);
# Line 2702 | Line 2544 | public class CompletableFutureTest exten
2544      {
2545          final CompletableFuture<Integer> f = new CompletableFuture<>();
2546          final FailingCompletableFutureFunction r
2547 <            = new FailingCompletableFutureFunction();
2547 >            = new FailingCompletableFutureFunction(m);
2548          if (!createIncomplete) f.complete(v1);
2549 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2549 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2550          if (createIncomplete) f.complete(v1);
2551  
2552          checkCompletedWithWrappedCFException(g);
# Line 2720 | Line 2562 | public class CompletableFutureTest exten
2562          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2563      {
2564          final CompletableFuture<Integer> f = new CompletableFuture<>();
2565 <        final CompletableFutureInc r = new CompletableFutureInc();
2565 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2566          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2567 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2567 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2568          if (createIncomplete) {
2569              checkIncomplete(g);
2570              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2894 | Line 2736 | public class CompletableFutureTest exten
2736  
2737              () -> f.thenCompose(null),
2738              () -> f.thenComposeAsync(null),
2739 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2739 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2740              () -> f.thenComposeAsync(null, exec),
2741  
2742              () -> f.exceptionally(null),

Diff Legend

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