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.56 by jsr166, Mon Jun 2 22:20:32 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 596 | Line 636 | public class CompletableFutureTest exten
636  
637          EXECUTOR {
638              public void checkExecutionMode() {
639 <                //TODO
639 >                assertTrue(ThreadExecutor.startedCurrentThread());
640              }
641              public <T> CompletableFuture<Void> thenRun
642                  (CompletableFuture<T> f, Runnable a) {
# Line 909 | Line 949 | public class CompletableFutureTest exten
949       * runAsync completes after running Runnable
950       */
951      public void testRunAsync() {
952 <        Noop r = new Noop();
952 >        Noop r = new Noop(ExecutionMode.ASYNC);
953          CompletableFuture<Void> f = CompletableFuture.runAsync(r);
954          assertNull(f.join());
955          assertEquals(1, r.invocationCount);
# Line 920 | Line 960 | public class CompletableFutureTest exten
960       * runAsync with executor completes after running Runnable
961       */
962      public void testRunAsync2() {
963 <        Noop r = new Noop();
963 >        Noop r = new Noop(ExecutionMode.EXECUTOR);
964          ThreadExecutor exec = new ThreadExecutor();
965          CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
966          assertNull(f.join());
# Line 933 | Line 973 | public class CompletableFutureTest exten
973       * failing runAsync completes exceptionally after running Runnable
974       */
975      public void testRunAsync3() {
976 <        FailingRunnable r = new FailingRunnable();
976 >        FailingRunnable r = new FailingRunnable(ExecutionMode.ASYNC);
977          CompletableFuture<Void> f = CompletableFuture.runAsync(r);
978          checkCompletedWithWrappedCFException(f);
979          assertEquals(1, r.invocationCount);
# Line 963 | Line 1003 | public class CompletableFutureTest exten
1003       * Failing supplyAsync completes exceptionally
1004       */
1005      public void testSupplyAsync3() {
1006 <        FailingSupplier r = new FailingSupplier();
1006 >        FailingSupplier r = new FailingSupplier(ExecutionMode.ASYNC);
1007          CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
1008          checkCompletedWithWrappedCFException(f);
1009          assertEquals(1, r.invocationCount);
# Line 980 | Line 1020 | public class CompletableFutureTest exten
1020          for (Integer v1 : new Integer[] { 1, null })
1021      {
1022          final CompletableFuture<Integer> f = new CompletableFuture<>();
1023 <        final Noop r = new Noop();
1023 >        final Noop r = new Noop(m);
1024          if (!createIncomplete) f.complete(v1);
1025          final CompletableFuture<Void> g = m.thenRun(f, r);
1026          if (createIncomplete) {
# Line 1003 | Line 1043 | public class CompletableFutureTest exten
1043      {
1044          final CFException ex = new CFException();
1045          final CompletableFuture<Integer> f = new CompletableFuture<>();
1046 <        final Noop r = new Noop();
1046 >        final Noop r = new Noop(m);
1047          if (!createIncomplete) f.completeExceptionally(ex);
1048          final CompletableFuture<Void> g = m.thenRun(f, r);
1049          if (createIncomplete) {
# Line 1025 | Line 1065 | public class CompletableFutureTest exten
1065          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1066      {
1067          final CompletableFuture<Integer> f = new CompletableFuture<>();
1068 <        final Noop r = new Noop();
1068 >        final Noop r = new Noop(m);
1069          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1070 <        final CompletableFuture<Void> g = f.thenRun(r);
1070 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1071          if (createIncomplete) {
1072              checkIncomplete(g);
1073              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1047 | Line 1087 | public class CompletableFutureTest exten
1087          for (Integer v1 : new Integer[] { 1, null })
1088      {
1089          final CompletableFuture<Integer> f = new CompletableFuture<>();
1090 <        final FailingRunnable r = new FailingRunnable();
1090 >        final FailingRunnable r = new FailingRunnable(m);
1091          if (!createIncomplete) f.complete(v1);
1092 <        final CompletableFuture<Void> g = f.thenRun(r);
1092 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1093          if (createIncomplete) {
1094              checkIncomplete(g);
1095              f.complete(v1);
# Line 1068 | Line 1108 | public class CompletableFutureTest exten
1108          for (Integer v1 : new Integer[] { 1, null })
1109      {
1110          final CompletableFuture<Integer> f = new CompletableFuture<>();
1111 <        final IncFunction r = new IncFunction();
1111 >        final IncFunction r = new IncFunction(m);
1112          if (!createIncomplete) f.complete(v1);
1113          final CompletableFuture<Integer> g = m.thenApply(f, r);
1114          if (createIncomplete) {
# Line 1091 | Line 1131 | public class CompletableFutureTest exten
1131      {
1132          final CFException ex = new CFException();
1133          final CompletableFuture<Integer> f = new CompletableFuture<>();
1134 <        final IncFunction r = new IncFunction();
1134 >        final IncFunction r = new IncFunction(m);
1135          if (!createIncomplete) f.completeExceptionally(ex);
1136          final CompletableFuture<Integer> g = m.thenApply(f, r);
1137          if (createIncomplete) {
# Line 1113 | Line 1153 | public class CompletableFutureTest exten
1153          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1154      {
1155          final CompletableFuture<Integer> f = new CompletableFuture<>();
1156 <        final IncFunction r = new IncFunction();
1156 >        final IncFunction r = new IncFunction(m);
1157          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1158 <        final CompletableFuture<Integer> g = f.thenApply(r);
1158 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1159          if (createIncomplete) {
1160              checkIncomplete(g);
1161              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1135 | Line 1175 | public class CompletableFutureTest exten
1175          for (Integer v1 : new Integer[] { 1, null })
1176      {
1177          final CompletableFuture<Integer> f = new CompletableFuture<>();
1178 <        final FailingFunction r = new FailingFunction();
1178 >        final FailingFunction r = new FailingFunction(m);
1179          if (!createIncomplete) f.complete(v1);
1180 <        final CompletableFuture<Integer> g = f.thenApply(r);
1180 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1181          if (createIncomplete) {
1182              checkIncomplete(g);
1183              f.complete(v1);
# Line 1202 | Line 1242 | public class CompletableFutureTest exten
1242          for (Integer v1 : new Integer[] { 1, null })
1243      {
1244          final CompletableFuture<Integer> f = new CompletableFuture<>();
1245 <        final FailingConsumer r = new FailingConsumer();
1245 >        final FailingConsumer r = new FailingConsumer(m);
1246          if (!createIncomplete) f.complete(v1);
1247 <        final CompletableFuture<Void> g = f.thenAccept(r);
1247 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1248          if (createIncomplete) {
1249              checkIncomplete(g);
1250              f.complete(v1);
# Line 1225 | Line 1265 | public class CompletableFutureTest exten
1265          final CompletableFuture<Integer> f = new CompletableFuture<>();
1266          final IncAction r = new IncAction();
1267          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1268 <        final CompletableFuture<Void> g = f.thenAccept(r);
1268 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1269          if (createIncomplete) {
1270              checkIncomplete(g);
1271              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1249 | Line 1289 | public class CompletableFutureTest exten
1289      {
1290          final CompletableFuture<Integer> f = new CompletableFuture<>();
1291          final CompletableFuture<Integer> g = new CompletableFuture<>();
1292 <        final SubtractFunction r = new SubtractFunction();
1292 >        final SubtractFunction r = new SubtractFunction(m);
1293  
1294          if (fFirst) f.complete(v1); else g.complete(v2);
1295          if (!createIncomplete)
# Line 1280 | Line 1320 | public class CompletableFutureTest exten
1320          final CompletableFuture<Integer> f = new CompletableFuture<>();
1321          final CompletableFuture<Integer> g = new CompletableFuture<>();
1322          final CFException ex = new CFException();
1323 <        final SubtractFunction r = new SubtractFunction();
1323 >        final SubtractFunction r = new SubtractFunction(m);
1324  
1325          (fFirst ? f : g).complete(v1);
1326          if (!createIncomplete)
# Line 1308 | Line 1348 | public class CompletableFutureTest exten
1348      {
1349          final CompletableFuture<Integer> f = new CompletableFuture<>();
1350          final CompletableFuture<Integer> g = new CompletableFuture<>();
1351 <        final FailingBiFunction r = new FailingBiFunction();
1351 >        final FailingBiFunction r = new FailingBiFunction(m);
1352          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1353  
1354          if (fFirst) {
# Line 1336 | Line 1376 | public class CompletableFutureTest exten
1376      {
1377          final CompletableFuture<Integer> f = new CompletableFuture<>();
1378          final CompletableFuture<Integer> g = new CompletableFuture<>();
1379 <        final SubtractFunction r = new SubtractFunction();
1379 >        final SubtractFunction r = new SubtractFunction(m);
1380  
1381          (fFirst ? f : g).complete(v1);
1382          if (!createIncomplete)
# Line 1366 | Line 1406 | public class CompletableFutureTest exten
1406      {
1407          final CompletableFuture<Integer> f = new CompletableFuture<>();
1408          final CompletableFuture<Integer> g = new CompletableFuture<>();
1409 <        final SubtractAction r = new SubtractAction();
1409 >        final SubtractAction r = new SubtractAction(m);
1410  
1411          if (fFirst) f.complete(v1); else g.complete(v2);
1412          if (!createIncomplete)
# Line 1397 | Line 1437 | public class CompletableFutureTest exten
1437          final CompletableFuture<Integer> f = new CompletableFuture<>();
1438          final CompletableFuture<Integer> g = new CompletableFuture<>();
1439          final CFException ex = new CFException();
1440 <        final SubtractAction r = new SubtractAction();
1440 >        final SubtractAction r = new SubtractAction(m);
1441  
1442          (fFirst ? f : g).complete(v1);
1443          if (!createIncomplete)
# Line 1425 | Line 1465 | public class CompletableFutureTest exten
1465      {
1466          final CompletableFuture<Integer> f = new CompletableFuture<>();
1467          final CompletableFuture<Integer> g = new CompletableFuture<>();
1468 <        final FailingBiConsumer r = new FailingBiConsumer();
1468 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1469          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1470  
1471          if (fFirst) {
# Line 1453 | Line 1493 | public class CompletableFutureTest exten
1493      {
1494          final CompletableFuture<Integer> f = new CompletableFuture<>();
1495          final CompletableFuture<Integer> g = new CompletableFuture<>();
1496 <        final SubtractAction r = new SubtractAction();
1496 >        final SubtractAction r = new SubtractAction(m);
1497  
1498          (fFirst ? f : g).complete(v1);
1499          if (!createIncomplete)
# Line 1474 | Line 1514 | public class CompletableFutureTest exten
1514       * runAfterBoth result completes normally after normal
1515       * completion of sources
1516       */
1517 <    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() {
1517 >    public void testRunAfterBoth_normalCompletion() {
1518          for (ExecutionMode m : ExecutionMode.values())
1519 +        for (boolean createIncomplete : new boolean[] { true, false })
1520 +        for (boolean fFirst : new boolean[] { true, false })
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();
1526 >        final Noop r = new Noop(m);
1527  
1528 <        f.complete(v1);
1529 <        g.complete(v2);
1528 >        if (fFirst) f.complete(v1); else g.complete(v2);
1529 >        if (!createIncomplete)
1530 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1531          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1532 +        if (createIncomplete) {
1533 +            checkIncomplete(h);
1534 +            assertEquals(0, r.invocationCount);
1535 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1536 +        }
1537  
1538          checkCompletedNormally(h, null);
1539          assertEquals(1, r.invocationCount);
# Line 1558 | Line 1545 | public class CompletableFutureTest exten
1545       * runAfterBoth result completes exceptionally after exceptional
1546       * completion of either source
1547       */
1548 <    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() {
1548 >    public void testRunAfterBoth_exceptionalCompletion() {
1549          for (ExecutionMode m : ExecutionMode.values())
1550 +        for (boolean createIncomplete : new boolean[] { true, false })
1551 +        for (boolean fFirst : new boolean[] { true, false })
1552          for (Integer v1 : new Integer[] { 1, null })
1553      {
1554          final CompletableFuture<Integer> f = new CompletableFuture<>();
1555          final CompletableFuture<Integer> g = new CompletableFuture<>();
1626 –        final Noop r = new Noop();
1556          final CFException ex = new CFException();
1557 +        final Noop r = new Noop(m);
1558  
1559 <        f.completeExceptionally(ex);
1560 <        g.complete(v1);
1559 >        (fFirst ? f : g).complete(v1);
1560 >        if (!createIncomplete)
1561 >            (!fFirst ? f : g).completeExceptionally(ex);
1562          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1563 +        if (createIncomplete) {
1564 +            checkIncomplete(h);
1565 +            (!fFirst ? f : g).completeExceptionally(ex);
1566 +        }
1567  
1568          checkCompletedWithWrappedCFException(h, ex);
1634 –        checkCompletedWithWrappedCFException(f, ex);
1569          assertEquals(0, r.invocationCount);
1570 <        checkCompletedNormally(g, v1);
1570 >        checkCompletedNormally(fFirst ? f : g, v1);
1571 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1572      }}
1573  
1574      /**
1575       * runAfterBoth result completes exceptionally if action does
1576       */
1577 <    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() {
1577 >    public void testRunAfterBoth_actionFailed() {
1578          for (ExecutionMode m : ExecutionMode.values())
1579 +        for (boolean fFirst : new boolean[] { true, false })
1580          for (Integer v1 : new Integer[] { 1, null })
1581          for (Integer v2 : new Integer[] { 2, null })
1582      {
1583          final CompletableFuture<Integer> f = new CompletableFuture<>();
1584          final CompletableFuture<Integer> g = new CompletableFuture<>();
1585 <        final FailingRunnable r = new FailingRunnable();
1669 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1585 >        final FailingRunnable r = new FailingRunnable(m);
1586  
1587 <        g.complete(v2);
1588 <        checkIncomplete(h);
1589 <        f.complete(v1);
1587 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r);
1588 >        if (fFirst) {
1589 >            f.complete(v1);
1590 >            g.complete(v2);
1591 >        } else {
1592 >            g.complete(v2);
1593 >            f.complete(v1);
1594 >        }
1595 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r);
1596  
1597 <        checkCompletedWithWrappedCFException(h);
1597 >        checkCompletedWithWrappedCFException(h1);
1598 >        checkCompletedWithWrappedCFException(h2);
1599          checkCompletedNormally(f, v1);
1600          checkCompletedNormally(g, v2);
1601      }}
# Line 1680 | Line 1603 | public class CompletableFutureTest exten
1603      /**
1604       * runAfterBoth result completes exceptionally if either source cancelled
1605       */
1606 <    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() {
1606 >    public void testRunAfterBoth_sourceCancelled() {
1607          for (ExecutionMode m : ExecutionMode.values())
1608          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1609 +        for (boolean createIncomplete : new boolean[] { true, false })
1610 +        for (boolean fFirst : new boolean[] { true, false })
1611          for (Integer v1 : new Integer[] { 1, null })
1612      {
1613          final CompletableFuture<Integer> f = new CompletableFuture<>();
1614          final CompletableFuture<Integer> g = new CompletableFuture<>();
1615 <        final Noop r = new Noop();
1615 >        final Noop r = new Noop(m);
1616  
1732 –        assertTrue(g.cancel(mayInterruptIfRunning));
1733 –        f.complete(v1);
1734 –        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1617  
1618 <        checkCompletedWithWrappedCancellationException(h);
1619 <        checkCancelled(g);
1620 <        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();
1750 <
1751 <        assertTrue(f.cancel(mayInterruptIfRunning));
1752 <        g.complete(v1);
1618 >        (fFirst ? f : g).complete(v1);
1619 >        if (!createIncomplete)
1620 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1621          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1622 +        if (createIncomplete) {
1623 +            checkIncomplete(h);
1624 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1625 +        }
1626  
1627          checkCompletedWithWrappedCancellationException(h);
1628 <        checkCancelled(f);
1628 >        checkCancelled(!fFirst ? f : g);
1629          assertEquals(0, r.invocationCount);
1630 <        checkCompletedNormally(g, v1);
1630 >        checkCompletedNormally(fFirst ? f : g, v1);
1631      }}
1632  
1633      /**
1634       * applyToEither result completes normally after normal completion
1635       * of either source
1636       */
1637 <    public void testApplyToEither_normalCompletion1() {
1637 >    public void testApplyToEither_normalCompletion() {
1638          for (ExecutionMode m : ExecutionMode.values())
1639 +        for (boolean createIncomplete : new boolean[] { true, false })
1640 +        for (boolean fFirst : new boolean[] { true, false })
1641          for (Integer v1 : new Integer[] { 1, null })
1642          for (Integer v2 : new Integer[] { 2, null })
1643      {
1644          final CompletableFuture<Integer> f = new CompletableFuture<>();
1645          final CompletableFuture<Integer> g = new CompletableFuture<>();
1646 <        final IncFunction r = new IncFunction();
1773 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1646 >        final IncFunction r = new IncFunction(m);
1647  
1648 <        f.complete(v1);
1649 <        checkCompletedNormally(h, inc(v1));
1650 <        g.complete(v2);
1648 >        if (!createIncomplete)
1649 >            if (fFirst) f.complete(v1); else g.complete(v2);
1650 >        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1651 >        if (createIncomplete) {
1652 >            checkIncomplete(h);
1653 >            assertEquals(0, r.invocationCount);
1654 >            if (fFirst) f.complete(v1); else g.complete(v2);
1655 >        }
1656 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1657 >        if (!fFirst) f.complete(v1); else g.complete(v2);
1658  
1659          checkCompletedNormally(f, v1);
1660          checkCompletedNormally(g, v2);
1661 <        checkCompletedNormally(h, inc(v1));
1661 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1662      }}
1663  
1664 <    public void testApplyToEither_normalCompletion2() {
1664 >    public void testApplyToEither_normalCompletionBothAvailable() {
1665          for (ExecutionMode m : ExecutionMode.values())
1666 +        for (boolean fFirst : new boolean[] { true, false })
1667          for (Integer v1 : new Integer[] { 1, null })
1668          for (Integer v2 : new Integer[] { 2, null })
1669      {
1670          final CompletableFuture<Integer> f = new CompletableFuture<>();
1671          final CompletableFuture<Integer> g = new CompletableFuture<>();
1672 <        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 <        }}
1672 >        final IncFunction r = new IncFunction(m);
1673  
1674 <    public void testApplyToEither_normalCompletion3() {
1675 <        for (ExecutionMode m : ExecutionMode.values())
1676 <        for (Integer v1 : new Integer[] { 1, null })
1677 <        for (Integer v2 : new Integer[] { 2, null })
1678 <    {
1679 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1680 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1810 <        final IncFunction r = new IncFunction();
1674 >        if (fFirst) {
1675 >            f.complete(v1);
1676 >            g.complete(v2);
1677 >        } else {
1678 >            g.complete(v2);
1679 >            f.complete(v1);
1680 >        }
1681  
1812 –        f.complete(v1);
1813 –        g.complete(v2);
1682          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1683  
1684          checkCompletedNormally(f, v1);
# Line 1828 | Line 1696 | public class CompletableFutureTest exten
1696       */
1697      public void testApplyToEither_exceptionalCompletion1() {
1698          for (ExecutionMode m : ExecutionMode.values())
1699 +        for (boolean createIncomplete : new boolean[] { true, false })
1700 +        for (boolean fFirst : new boolean[] { true, false })
1701          for (Integer v1 : new Integer[] { 1, null })
1702      {
1703          final CompletableFuture<Integer> f = new CompletableFuture<>();
1704          final CompletableFuture<Integer> g = new CompletableFuture<>();
1835 –        final IncFunction r = new IncFunction();
1836 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1705          final CFException ex = new CFException();
1706 +        final IncFunction r = new IncFunction(m);
1707  
1708 <        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();
1708 >        if (!createIncomplete) (fFirst ? f : g).completeExceptionally(ex);
1709          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1710 <        final CFException ex = new CFException();
1710 >        if (createIncomplete) {
1711 >            checkIncomplete(h);
1712 >            assertEquals(0, r.invocationCount);
1713 >            (fFirst ? f : g).completeExceptionally(ex);
1714 >        }
1715  
1859 –        g.completeExceptionally(ex);
1716          checkCompletedWithWrappedCFException(h, ex);
1717 <        f.complete(v1);
1717 >        (!fFirst ? f : g).complete(v1);
1718  
1719          assertEquals(0, r.invocationCount);
1720 <        checkCompletedNormally(f, v1);
1721 <        checkCompletedWithWrappedCFException(g, ex);
1720 >        checkCompletedNormally(!fFirst ? f : g, v1);
1721 >        checkCompletedWithWrappedCFException(fFirst ? f : g, ex);
1722          checkCompletedWithWrappedCFException(h, ex);
1723      }}
1724  
1725 <    public void testApplyToEither_exceptionalCompletion3() {
1725 >    public void testApplyToEither_exceptionalCompletion2() {
1726          for (ExecutionMode m : ExecutionMode.values())
1727 +        for (boolean reverseArgs : new boolean[] { true, false })
1728 +        for (boolean fFirst : new boolean[] { true, false })
1729          for (Integer v1 : new Integer[] { 1, null })
1730      {
1731          final CompletableFuture<Integer> f = new CompletableFuture<>();
1732          final CompletableFuture<Integer> g = new CompletableFuture<>();
1733 <        final IncFunction r = new IncFunction();
1733 >        final IncFunction r1 = new IncFunction(m);
1734 >        final IncFunction r2 = new IncFunction(m);
1735          final CFException ex = new CFException();
1736 <
1737 <        g.completeExceptionally(ex);
1738 <        f.complete(v1);
1739 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1736 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1737 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1738 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1739 >        if (fFirst) {
1740 >            f.complete(v1);
1741 >            g.completeExceptionally(ex);
1742 >        } else {
1743 >            g.completeExceptionally(ex);
1744 >            f.complete(v1);
1745 >        }
1746 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1747  
1748          // unspecified behavior
1883 –        Integer v;
1749          try {
1750 <            assertEquals(inc(v1), h.join());
1751 <            assertEquals(1, r.invocationCount);
1750 >            assertEquals(inc(v1), h1.join());
1751 >            assertEquals(1, r1.invocationCount);
1752          } catch (CompletionException ok) {
1753 <            checkCompletedWithWrappedCFException(h, ex);
1754 <            assertEquals(0, r.invocationCount);
1753 >            checkCompletedWithWrappedCFException(h1, ex);
1754 >            assertEquals(0, r1.invocationCount);
1755          }
1756  
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;
1757          try {
1758 <            assertEquals(inc(v1), h.join());
1759 <            assertEquals(1, r.invocationCount);
1758 >            assertEquals(inc(v1), h2.join());
1759 >            assertEquals(1, r2.invocationCount);
1760          } catch (CompletionException ok) {
1761 <            checkCompletedWithWrappedCFException(h, ex);
1762 <            assertEquals(0, r.invocationCount);
1761 >            checkCompletedWithWrappedCFException(h2, ex);
1762 >            assertEquals(0, r2.invocationCount);
1763          }
1764  
1765 <        checkCompletedWithWrappedCFException(f, ex);
1766 <        checkCompletedNormally(g, v1);
1765 >        checkCompletedWithWrappedCFException(g, ex);
1766 >        checkCompletedNormally(f, v1);
1767      }}
1768  
1769      /**
# Line 1930 | Line 1776 | public class CompletableFutureTest exten
1776      {
1777          final CompletableFuture<Integer> f = new CompletableFuture<>();
1778          final CompletableFuture<Integer> g = new CompletableFuture<>();
1779 <        final FailingFunction r = new FailingFunction();
1779 >        final FailingFunction r = new FailingFunction(m);
1780          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1781  
1782          f.complete(v1);
# Line 1947 | Line 1793 | public class CompletableFutureTest exten
1793      {
1794          final CompletableFuture<Integer> f = new CompletableFuture<>();
1795          final CompletableFuture<Integer> g = new CompletableFuture<>();
1796 <        final FailingFunction r = new FailingFunction();
1796 >        final FailingFunction r = new FailingFunction(m);
1797          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1798  
1799          g.complete(v2);
# Line 1963 | Line 1809 | public class CompletableFutureTest exten
1809      public void testApplyToEither_sourceCancelled1() {
1810          for (ExecutionMode m : ExecutionMode.values())
1811          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1812 +        for (boolean createIncomplete : new boolean[] { true, false })
1813 +        for (boolean fFirst : new boolean[] { true, false })
1814          for (Integer v1 : new Integer[] { 1, null })
1815      {
1816          final CompletableFuture<Integer> f = new CompletableFuture<>();
1817          final CompletableFuture<Integer> g = new CompletableFuture<>();
1818 <        final IncFunction r = new IncFunction();
1971 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1818 >        final IncFunction r = new IncFunction(m);
1819  
1820 <        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();
1820 >        if (!createIncomplete) assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1821          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1822 +        if (createIncomplete) {
1823 +            checkIncomplete(h);
1824 +            assertEquals(0, r.invocationCount);
1825 +            assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1826 +        }
1827  
1993 –        assertTrue(g.cancel(mayInterruptIfRunning));
1828          checkCompletedWithWrappedCancellationException(h);
1829 <        f.complete(v1);
1829 >        (!fFirst ? f : g).complete(v1);
1830  
1997 –        checkCancelled(g);
1831          assertEquals(0, r.invocationCount);
1832 <        checkCompletedNormally(f, v1);
1832 >        checkCompletedNormally(!fFirst ? f : g, v1);
1833 >        checkCancelled(fFirst ? f : g);
1834          checkCompletedWithWrappedCancellationException(h);
1835      }}
1836  
1837 <    public void testApplyToEither_sourceCancelled3() {
1837 >    public void testApplyToEither_sourceCancelled2() {
1838          for (ExecutionMode m : ExecutionMode.values())
1839          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1840 +        for (boolean reverseArgs : new boolean[] { true, false })
1841 +        for (boolean fFirst : new boolean[] { true, false })
1842          for (Integer v1 : new Integer[] { 1, null })
1843      {
1844          final CompletableFuture<Integer> f = new CompletableFuture<>();
1845          final CompletableFuture<Integer> g = new CompletableFuture<>();
1846 <        final IncFunction r = new IncFunction();
1846 >        final IncFunction r1 = new IncFunction(m);
1847 >        final IncFunction r2 = new IncFunction(m);
1848 >        final CFException ex = new CFException();
1849 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1850 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1851  
1852 <        assertTrue(g.cancel(mayInterruptIfRunning));
1853 <        f.complete(v1);
1854 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1852 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1853 >        if (fFirst) {
1854 >            f.complete(v1);
1855 >            assertTrue(g.cancel(mayInterruptIfRunning));
1856 >        } else {
1857 >            assertTrue(g.cancel(mayInterruptIfRunning));
1858 >            f.complete(v1);
1859 >        }
1860 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1861  
1862          // unspecified behavior
2017 –        Integer v;
1863          try {
1864 <            assertEquals(inc(v1), h.join());
1865 <            assertEquals(1, r.invocationCount);
1864 >            assertEquals(inc(v1), h1.join());
1865 >            assertEquals(1, r1.invocationCount);
1866          } catch (CompletionException ok) {
1867 <            checkCompletedWithWrappedCancellationException(h);
1868 <            assertEquals(0, r.invocationCount);
1867 >            checkCompletedWithWrappedCancellationException(h1);
1868 >            assertEquals(0, r1.invocationCount);
1869          }
1870  
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;
1871          try {
1872 <            assertEquals(inc(v1), h.join());
1873 <            assertEquals(1, r.invocationCount);
1872 >            assertEquals(inc(v1), h2.join());
1873 >            assertEquals(1, r2.invocationCount);
1874          } catch (CompletionException ok) {
1875 <            checkCompletedWithWrappedCancellationException(h);
1876 <            assertEquals(0, r.invocationCount);
1875 >            checkCompletedWithWrappedCancellationException(h2);
1876 >            assertEquals(0, r2.invocationCount);
1877          }
1878  
1879 <        checkCancelled(f);
1880 <        checkCompletedNormally(g, v1);
1879 >        checkCancelled(g);
1880 >        checkCompletedNormally(f, v1);
1881      }}
1882  
1883      /**
# Line 2230 | Line 2056 | public class CompletableFutureTest exten
2056      {
2057          final CompletableFuture<Integer> f = new CompletableFuture<>();
2058          final CompletableFuture<Integer> g = new CompletableFuture<>();
2059 <        final FailingConsumer r = new FailingConsumer();
2059 >        final FailingConsumer r = new FailingConsumer(m);
2060          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2061  
2062          f.complete(v1);
# Line 2247 | Line 2073 | public class CompletableFutureTest exten
2073      {
2074          final CompletableFuture<Integer> f = new CompletableFuture<>();
2075          final CompletableFuture<Integer> g = new CompletableFuture<>();
2076 <        final FailingConsumer r = new FailingConsumer();
2076 >        final FailingConsumer r = new FailingConsumer(m);
2077          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2078  
2079          g.complete(v2);
# Line 2367 | Line 2193 | public class CompletableFutureTest exten
2193      {
2194          final CompletableFuture<Integer> f = new CompletableFuture<>();
2195          final CompletableFuture<Integer> g = new CompletableFuture<>();
2196 <        final Noop r = new Noop();
2196 >        final Noop r = new Noop(m);
2197          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2198  
2199          f.complete(v1);
# Line 2388 | Line 2214 | public class CompletableFutureTest exten
2214      {
2215          final CompletableFuture<Integer> f = new CompletableFuture<>();
2216          final CompletableFuture<Integer> g = new CompletableFuture<>();
2217 <        final Noop r = new Noop();
2217 >        final Noop r = new Noop(m);
2218          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2219  
2220          g.complete(v2);
# Line 2409 | Line 2235 | public class CompletableFutureTest exten
2235      {
2236          final CompletableFuture<Integer> f = new CompletableFuture<>();
2237          final CompletableFuture<Integer> g = new CompletableFuture<>();
2238 <        final Noop r = new Noop();
2238 >        final Noop r = new Noop(m);
2239  
2240          f.complete(v1);
2241          g.complete(v2);
# Line 2431 | Line 2257 | public class CompletableFutureTest exten
2257      {
2258          final CompletableFuture<Integer> f = new CompletableFuture<>();
2259          final CompletableFuture<Integer> g = new CompletableFuture<>();
2260 <        final Noop r = new Noop();
2260 >        final Noop r = new Noop(m);
2261          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2262          final CFException ex = new CFException();
2263  
# Line 2451 | Line 2277 | public class CompletableFutureTest exten
2277      {
2278          final CompletableFuture<Integer> f = new CompletableFuture<>();
2279          final CompletableFuture<Integer> g = new CompletableFuture<>();
2280 <        final Noop r = new Noop();
2280 >        final Noop r = new Noop(m);
2281          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2282          final CFException ex = new CFException();
2283  
# Line 2471 | Line 2297 | public class CompletableFutureTest exten
2297      {
2298          final CompletableFuture<Integer> f = new CompletableFuture<>();
2299          final CompletableFuture<Integer> g = new CompletableFuture<>();
2300 <        final Noop r = new Noop();
2300 >        final Noop r = new Noop(m);
2301          final CFException ex = new CFException();
2302  
2303          g.completeExceptionally(ex);
# Line 2498 | Line 2324 | public class CompletableFutureTest exten
2324      {
2325          final CompletableFuture<Integer> f = new CompletableFuture<>();
2326          final CompletableFuture<Integer> g = new CompletableFuture<>();
2327 <        final Noop r = new Noop();
2327 >        final Noop r = new Noop(m);
2328          final CFException ex = new CFException();
2329  
2330          f.completeExceptionally(ex);
# Line 2529 | Line 2355 | public class CompletableFutureTest exten
2355      {
2356          final CompletableFuture<Integer> f = new CompletableFuture<>();
2357          final CompletableFuture<Integer> g = new CompletableFuture<>();
2358 <        final FailingRunnable r = new FailingRunnable();
2358 >        final FailingRunnable r = new FailingRunnable(m);
2359          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2360  
2361          f.complete(v1);
# Line 2546 | Line 2372 | public class CompletableFutureTest exten
2372      {
2373          final CompletableFuture<Integer> f = new CompletableFuture<>();
2374          final CompletableFuture<Integer> g = new CompletableFuture<>();
2375 <        final FailingRunnable r = new FailingRunnable();
2375 >        final FailingRunnable r = new FailingRunnable(m);
2376          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2377  
2378          g.complete(v2);
# Line 2566 | Line 2392 | public class CompletableFutureTest exten
2392      {
2393          final CompletableFuture<Integer> f = new CompletableFuture<>();
2394          final CompletableFuture<Integer> g = new CompletableFuture<>();
2395 <        final Noop r = new Noop();
2395 >        final Noop r = new Noop(m);
2396          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2397  
2398          assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2586 | Line 2412 | public class CompletableFutureTest exten
2412      {
2413          final CompletableFuture<Integer> f = new CompletableFuture<>();
2414          final CompletableFuture<Integer> g = new CompletableFuture<>();
2415 <        final Noop r = new Noop();
2415 >        final Noop r = new Noop(m);
2416          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2417  
2418          assertTrue(g.cancel(mayInterruptIfRunning));
# Line 2606 | Line 2432 | public class CompletableFutureTest exten
2432      {
2433          final CompletableFuture<Integer> f = new CompletableFuture<>();
2434          final CompletableFuture<Integer> g = new CompletableFuture<>();
2435 <        final Noop r = new Noop();
2435 >        final Noop r = new Noop(m);
2436  
2437          assertTrue(g.cancel(mayInterruptIfRunning));
2438          f.complete(v1);
# Line 2633 | Line 2459 | public class CompletableFutureTest exten
2459      {
2460          final CompletableFuture<Integer> f = new CompletableFuture<>();
2461          final CompletableFuture<Integer> g = new CompletableFuture<>();
2462 <        final Noop r = new Noop();
2462 >        final Noop r = new Noop(m);
2463  
2464          assertTrue(f.cancel(mayInterruptIfRunning));
2465          g.complete(v1);
# Line 2662 | Line 2488 | public class CompletableFutureTest exten
2488          for (Integer v1 : new Integer[] { 1, null })
2489      {
2490          final CompletableFuture<Integer> f = new CompletableFuture<>();
2491 <        final CompletableFutureInc r = new CompletableFutureInc();
2491 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2492          if (!createIncomplete) f.complete(v1);
2493 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2493 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2494          if (createIncomplete) f.complete(v1);
2495  
2496          checkCompletedNormally(g, inc(v1));
# Line 2681 | Line 2507 | public class CompletableFutureTest exten
2507          for (boolean createIncomplete : new boolean[] { true, false })
2508      {
2509          final CFException ex = new CFException();
2510 <        final CompletableFutureInc r = new CompletableFutureInc();
2510 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2511          final CompletableFuture<Integer> f = new CompletableFuture<>();
2512          if (!createIncomplete) f.completeExceptionally(ex);
2513 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2513 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2514          if (createIncomplete) f.completeExceptionally(ex);
2515  
2516          checkCompletedWithWrappedCFException(g, ex);
# Line 2702 | Line 2528 | public class CompletableFutureTest exten
2528      {
2529          final CompletableFuture<Integer> f = new CompletableFuture<>();
2530          final FailingCompletableFutureFunction r
2531 <            = new FailingCompletableFutureFunction();
2531 >            = new FailingCompletableFutureFunction(m);
2532          if (!createIncomplete) f.complete(v1);
2533 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2533 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2534          if (createIncomplete) f.complete(v1);
2535  
2536          checkCompletedWithWrappedCFException(g);
# Line 2720 | Line 2546 | public class CompletableFutureTest exten
2546          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2547      {
2548          final CompletableFuture<Integer> f = new CompletableFuture<>();
2549 <        final CompletableFutureInc r = new CompletableFutureInc();
2549 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2550          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2551 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2551 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2552          if (createIncomplete) {
2553              checkIncomplete(g);
2554              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2894 | Line 2720 | public class CompletableFutureTest exten
2720  
2721              () -> f.thenCompose(null),
2722              () -> f.thenComposeAsync(null),
2723 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2723 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2724              () -> f.thenComposeAsync(null, exec),
2725  
2726              () -> f.exceptionally(null),

Diff Legend

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