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.17 by jsr166, Thu Apr 4 04:16:02 2013 UTC vs.
Revision 1.18 by jsr166, Sun Apr 7 14:54:06 2013 UTC

# Line 282 | Line 282 | public class CompletableFutureTest exten
282          checkCompletedNormally(f, "test");
283      }
284  
285 +    // Choose non-commutative actions for better coverage
286 +
287      static final Supplier<Integer> supplyOne =
288          () -> Integer.valueOf(1);
289      static final Function<Integer, Integer> inc =
290          (Integer x) -> Integer.valueOf(x.intValue() + 1);
291 <    static final BiFunction<Integer, Integer, Integer> add =
292 <        (Integer x, Integer y) -> Integer.valueOf(x.intValue() + y.intValue());
291 >    static final BiFunction<Integer, Integer, Integer> subtract =
292 >        (Integer x, Integer y) -> Integer.valueOf(x.intValue() - y.intValue());
293      static final class IncAction implements Consumer<Integer> {
294          int value;
295          public void accept(Integer x) { value = x.intValue() + 1; }
# Line 328 | Line 330 | public class CompletableFutureTest exten
330          public void run() { ran = true; throw new CFException(); }
331      }
332  
333 <    static final class CompletableFutureInc implements Function<Integer, CompletableFuture<Integer>> {
333 >    static final class CompletableFutureInc
334 >        implements Function<Integer, CompletableFuture<Integer>> {
335          public CompletableFuture<Integer> apply(Integer x) {
336              CompletableFuture<Integer> f = new CompletableFuture<Integer>();
337              f.complete(Integer.valueOf(x.intValue() + 1));
# Line 336 | Line 339 | public class CompletableFutureTest exten
339          }
340      }
341  
342 <    static final class FailingCompletableFutureFunction implements Function<Integer, CompletableFuture<Integer>> {
342 >    static final class FailingCompletableFutureFunction
343 >        implements Function<Integer, CompletableFuture<Integer>> {
344          boolean ran;
345          public CompletableFuture<Integer> apply(Integer x) {
346              ran = true; throw new CFException();
# Line 626 | Line 630 | public class CompletableFutureTest exten
630  
631  
632      /**
633 <     * thenCombine result completes normally after normal completion of sources
633 >     * thenCombine result completes normally after normal completion
634 >     * of sources
635       */
636      public void testThenCombine() {
637 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
633 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
634 <        CompletableFuture<Integer> g = f.thenCombine(f2, add);
635 <        f.complete(one);
636 <        checkIncomplete(g);
637 <        f2.complete(two);
638 <        checkCompletedNormally(g, three);
637 >        CompletableFuture<Integer> f, g, h;
638  
639          f = new CompletableFuture<Integer>();
640 <        f.complete(one);
641 <        f2 = new CompletableFuture<Integer>();
642 <        g = f.thenCombine(f2, add);
643 <        checkIncomplete(g);
644 <        f2.complete(two);
645 <        checkCompletedNormally(g, three);
640 >        g = new CompletableFuture<Integer>();
641 >        h = f.thenCombine(g, subtract);
642 >        f.complete(3);
643 >        checkIncomplete(h);
644 >        g.complete(1);
645 >        checkCompletedNormally(h, 2);
646 >
647 >        f = new CompletableFuture<Integer>();
648 >        g = new CompletableFuture<Integer>();
649 >        h = f.thenCombine(g, subtract);
650 >        g.complete(1);
651 >        checkIncomplete(h);
652 >        f.complete(3);
653 >        checkCompletedNormally(h, 2);
654 >
655 >        f = new CompletableFuture<Integer>();
656 >        g = new CompletableFuture<Integer>();
657 >        g.complete(1);
658 >        f.complete(3);
659 >        h = f.thenCombine(g, subtract);
660 >        checkCompletedNormally(h, 2);
661      }
662  
663      /**
# Line 651 | Line 665 | public class CompletableFutureTest exten
665       * completion of either source
666       */
667      public void testThenCombine2() {
668 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
669 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
670 <        CompletableFuture<Integer> g = f.thenCombine(f2, add);
668 >        CompletableFuture<Integer> f, g, h;
669 >
670 >        f = new CompletableFuture<Integer>();
671 >        g = new CompletableFuture<Integer>();
672 >        h = f.thenCombine(g, subtract);
673          f.completeExceptionally(new CFException());
674 <        f2.complete(two);
675 <        checkCompletedWithWrappedCFException(g);
674 >        checkIncomplete(h);
675 >        g.complete(1);
676 >        checkCompletedWithWrappedCFException(h);
677  
678          f = new CompletableFuture<Integer>();
679 <        f.complete(one);
680 <        f2 = new CompletableFuture<Integer>();
681 <        g = f.thenCombine(f2, add);
682 <        f2.completeExceptionally(new CFException());
683 <        checkCompletedWithWrappedCFException(g);
679 >        g = new CompletableFuture<Integer>();
680 >        h = f.thenCombine(g, subtract);
681 >        g.completeExceptionally(new CFException());
682 >        checkIncomplete(h);
683 >        f.complete(3);
684 >        checkCompletedWithWrappedCFException(h);
685 >
686 >        f = new CompletableFuture<Integer>();
687 >        g = new CompletableFuture<Integer>();
688 >        f.complete(3);
689 >        g.completeExceptionally(new CFException());
690 >        h = f.thenCombine(g, subtract);
691 >        checkCompletedWithWrappedCFException(h);
692 >
693 >        f = new CompletableFuture<Integer>();
694 >        g = new CompletableFuture<Integer>();
695 >        f.completeExceptionally(new CFException());
696 >        g.complete(3);
697 >        h = f.thenCombine(g, subtract);
698 >        checkCompletedWithWrappedCFException(h);
699      }
700  
701      /**
# Line 676 | Line 708 | public class CompletableFutureTest exten
708          CompletableFuture<Integer> g = f.thenCombine(f2, r);
709          f.complete(one);
710          checkIncomplete(g);
711 +        assertFalse(r.ran);
712          f2.complete(two);
713          checkCompletedWithWrappedCFException(g);
714 +        assertTrue(r.ran);
715      }
716  
717      /**
718       * thenCombine result completes exceptionally if either source cancelled
719       */
720      public void testThenCombine4() {
721 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
722 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
723 <        CompletableFuture<Integer> g = f.thenCombine(f2, add);
721 >        CompletableFuture<Integer> f, g, h;
722 >
723 >        f = new CompletableFuture<Integer>();
724 >        g = new CompletableFuture<Integer>();
725 >        h = f.thenCombine(g, subtract);
726          assertTrue(f.cancel(true));
727 <        f2.complete(two);
728 <        checkCompletedWithWrappedCancellationException(g);
727 >        checkIncomplete(h);
728 >        g.complete(1);
729 >        checkCompletedWithWrappedCancellationException(h);
730 >
731          f = new CompletableFuture<Integer>();
732 <        f2 = new CompletableFuture<Integer>();
733 <        g = f.thenCombine(f2, add);
734 <        f.complete(one);
735 <        assertTrue(f2.cancel(true));
736 <        checkCompletedWithWrappedCancellationException(g);
732 >        g = new CompletableFuture<Integer>();
733 >        h = f.thenCombine(g, subtract);
734 >        assertTrue(g.cancel(true));
735 >        checkIncomplete(h);
736 >        f.complete(3);
737 >        checkCompletedWithWrappedCancellationException(h);
738 >
739 >        f = new CompletableFuture<Integer>();
740 >        g = new CompletableFuture<Integer>();
741 >        assertTrue(f.cancel(true));
742 >        assertTrue(g.cancel(true));
743 >        h = f.thenCombine(g, subtract);
744 >        checkCompletedWithWrappedCancellationException(h);
745      }
746  
747      /**
# Line 1273 | Line 1319 | public class CompletableFutureTest exten
1319       * completion of sources
1320       */
1321      public void testThenCombineAsync() {
1322 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1323 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1324 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1325 <        f.complete(one);
1326 <        checkIncomplete(g);
1327 <        f2.complete(two);
1328 <        checkCompletedNormally(g, three);
1322 >        CompletableFuture<Integer> f, g, h;
1323 >
1324 >        f = new CompletableFuture<Integer>();
1325 >        g = new CompletableFuture<Integer>();
1326 >        h = f.thenCombineAsync(g, subtract);
1327 >        f.complete(3);
1328 >        checkIncomplete(h);
1329 >        g.complete(1);
1330 >        checkCompletedNormally(h, 2);
1331 >
1332 >        f = new CompletableFuture<Integer>();
1333 >        g = new CompletableFuture<Integer>();
1334 >        h = f.thenCombineAsync(g, subtract);
1335 >        g.complete(1);
1336 >        checkIncomplete(h);
1337 >        f.complete(3);
1338 >        checkCompletedNormally(h, 2);
1339 >
1340 >        f = new CompletableFuture<Integer>();
1341 >        g = new CompletableFuture<Integer>();
1342 >        g.complete(1);
1343 >        f.complete(3);
1344 >        h = f.thenCombineAsync(g, subtract);
1345 >        checkCompletedNormally(h, 2);
1346      }
1347  
1348      /**
1349       * thenCombineAsync result completes exceptionally after exceptional
1350 <     * completion of source
1350 >     * completion of either source
1351       */
1352      public void testThenCombineAsync2() {
1353 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1354 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1355 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1353 >        CompletableFuture<Integer> f, g, h;
1354 >
1355 >        f = new CompletableFuture<Integer>();
1356 >        g = new CompletableFuture<Integer>();
1357 >        h = f.thenCombineAsync(g, subtract);
1358          f.completeExceptionally(new CFException());
1359 <        f2.complete(two);
1360 <        checkCompletedWithWrappedCFException(g);
1359 >        checkIncomplete(h);
1360 >        g.complete(1);
1361 >        checkCompletedWithWrappedCFException(h);
1362  
1363          f = new CompletableFuture<Integer>();
1364 <        f2 = new CompletableFuture<Integer>();
1365 <        g = f.thenCombineAsync(f2, add);
1366 <        f.complete(one);
1367 <        f2.completeExceptionally(new CFException());
1368 <        checkCompletedWithWrappedCFException(g);
1364 >        g = new CompletableFuture<Integer>();
1365 >        h = f.thenCombineAsync(g, subtract);
1366 >        g.completeExceptionally(new CFException());
1367 >        checkIncomplete(h);
1368 >        f.complete(3);
1369 >        checkCompletedWithWrappedCFException(h);
1370 >
1371 >        f = new CompletableFuture<Integer>();
1372 >        g = new CompletableFuture<Integer>();
1373 >        g.completeExceptionally(new CFException());
1374 >        f.complete(3);
1375 >        h = f.thenCombineAsync(g, subtract);
1376 >        checkCompletedWithWrappedCFException(h);
1377      }
1378  
1379      /**
# Line 1312 | Line 1386 | public class CompletableFutureTest exten
1386          CompletableFuture<Integer> g = f.thenCombineAsync(f2, r);
1387          f.complete(one);
1388          checkIncomplete(g);
1389 +        assertFalse(r.ran);
1390          f2.complete(two);
1391          checkCompletedWithWrappedCFException(g);
1392 +        assertTrue(r.ran);
1393      }
1394  
1395      /**
1396       * thenCombineAsync result completes exceptionally if either source cancelled
1397       */
1398      public void testThenCombineAsync4() {
1399 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1400 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1401 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1399 >        CompletableFuture<Integer> f, g, h;
1400 >
1401 >        f = new CompletableFuture<Integer>();
1402 >        g = new CompletableFuture<Integer>();
1403 >        h = f.thenCombineAsync(g, subtract);
1404          assertTrue(f.cancel(true));
1405 <        f2.complete(two);
1406 <        checkCompletedWithWrappedCancellationException(g);
1405 >        checkIncomplete(h);
1406 >        g.complete(1);
1407 >        checkCompletedWithWrappedCancellationException(h);
1408  
1409          f = new CompletableFuture<Integer>();
1410 <        f2 = new CompletableFuture<Integer>();
1411 <        g = f.thenCombineAsync(f2, add);
1412 <        f.complete(one);
1413 <        assertTrue(f2.cancel(true));
1414 <        checkCompletedWithWrappedCancellationException(g);
1410 >        g = new CompletableFuture<Integer>();
1411 >        h = f.thenCombineAsync(g, subtract);
1412 >        assertTrue(g.cancel(true));
1413 >        checkIncomplete(h);
1414 >        f.complete(3);
1415 >        checkCompletedWithWrappedCancellationException(h);
1416 >
1417 >        f = new CompletableFuture<Integer>();
1418 >        g = new CompletableFuture<Integer>();
1419 >        g.complete(3);
1420 >        assertTrue(f.cancel(true));
1421 >        h = f.thenCombineAsync(g, subtract);
1422 >        checkCompletedWithWrappedCancellationException(h);
1423 >
1424 >        f = new CompletableFuture<Integer>();
1425 >        g = new CompletableFuture<Integer>();
1426 >        f.complete(3);
1427 >        assertTrue(g.cancel(true));
1428 >        h = f.thenCombineAsync(g, subtract);
1429 >        checkCompletedWithWrappedCancellationException(h);
1430      }
1431  
1432      /**
# Line 1891 | Line 1985 | public class CompletableFutureTest exten
1985          assertTrue(f.cancel(true));
1986          checkCompletedWithWrappedCancellationException(g);
1987      }
1988 +
1989      /**
1990       * thenCombineAsync result completes normally after normal
1991       * completion of sources
1992       */
1993      public void testThenCombineAsyncE() {
1994 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1995 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1996 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
1997 <        f.complete(one);
1998 <        checkIncomplete(g);
1999 <        f2.complete(two);
2000 <        checkCompletedNormally(g, three);
1994 >        CompletableFuture<Integer> f, g, h;
1995 >        ThreadExecutor e = new ThreadExecutor();
1996 >        int count = 0;
1997 >
1998 >        f = new CompletableFuture<Integer>();
1999 >        g = new CompletableFuture<Integer>();
2000 >        h = f.thenCombineAsync(g, subtract, e);
2001 >        f.complete(3);
2002 >        checkIncomplete(h);
2003 >        g.complete(1);
2004 >        checkCompletedNormally(h, 2);
2005 >        assertEquals(++count, e.count.get());
2006 >
2007 >        f = new CompletableFuture<Integer>();
2008 >        g = new CompletableFuture<Integer>();
2009 >        h = f.thenCombineAsync(g, subtract, e);
2010 >        g.complete(1);
2011 >        checkIncomplete(h);
2012 >        f.complete(3);
2013 >        checkCompletedNormally(h, 2);
2014 >        assertEquals(++count, e.count.get());
2015 >
2016 >        f = new CompletableFuture<Integer>();
2017 >        g = new CompletableFuture<Integer>();
2018 >        g.complete(1);
2019 >        f.complete(3);
2020 >        h = f.thenCombineAsync(g, subtract, e);
2021 >        checkCompletedNormally(h, 2);
2022 >        assertEquals(++count, e.count.get());
2023      }
2024  
2025      /**
2026       * thenCombineAsync result completes exceptionally after exceptional
2027 <     * completion of source
2027 >     * completion of either source
2028       */
2029      public void testThenCombineAsync2E() {
2030 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2031 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2032 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
2030 >        CompletableFuture<Integer> f, g, h;
2031 >        ThreadExecutor e = new ThreadExecutor();
2032 >        int count = 0;
2033 >
2034 >        f = new CompletableFuture<Integer>();
2035 >        g = new CompletableFuture<Integer>();
2036 >        h = f.thenCombineAsync(g, subtract, e);
2037          f.completeExceptionally(new CFException());
2038 <        f2.complete(two);
2039 <        checkCompletedWithWrappedCFException(g);
2038 >        checkIncomplete(h);
2039 >        g.complete(1);
2040 >        checkCompletedWithWrappedCFException(h);
2041  
2042          f = new CompletableFuture<Integer>();
2043 <        f2 = new CompletableFuture<Integer>();
2044 <        g = f.thenCombineAsync(f2, add, new ThreadExecutor());
2045 <        f.complete(one);
2046 <        f2.completeExceptionally(new CFException());
2047 <        checkCompletedWithWrappedCFException(g);
2043 >        g = new CompletableFuture<Integer>();
2044 >        h = f.thenCombineAsync(g, subtract, e);
2045 >        g.completeExceptionally(new CFException());
2046 >        checkIncomplete(h);
2047 >        f.complete(3);
2048 >        checkCompletedWithWrappedCFException(h);
2049 >
2050 >        f = new CompletableFuture<Integer>();
2051 >        g = new CompletableFuture<Integer>();
2052 >        g.completeExceptionally(new CFException());
2053 >        h = f.thenCombineAsync(g, subtract, e);
2054 >        checkIncomplete(h);
2055 >        f.complete(3);
2056 >        checkCompletedWithWrappedCFException(h);
2057 >
2058 >        assertEquals(0, e.count.get());
2059      }
2060  
2061      /**
# Line 1935 | Line 2068 | public class CompletableFutureTest exten
2068          CompletableFuture<Integer> g = f.thenCombineAsync(f2, r, new ThreadExecutor());
2069          f.complete(one);
2070          checkIncomplete(g);
2071 +        assertFalse(r.ran);
2072          f2.complete(two);
2073          checkCompletedWithWrappedCFException(g);
2074 +        assertTrue(r.ran);
2075      }
2076  
2077      /**
2078       * thenCombineAsync result completes exceptionally if either source cancelled
2079       */
2080      public void testThenCombineAsync4E() {
2081 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2082 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2083 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
2081 >        CompletableFuture<Integer> f, g, h;
2082 >        ThreadExecutor e = new ThreadExecutor();
2083 >
2084 >        f = new CompletableFuture<Integer>();
2085 >        g = new CompletableFuture<Integer>();
2086 >        h = f.thenCombineAsync(g, subtract, e);
2087          assertTrue(f.cancel(true));
2088 <        f2.complete(two);
2089 <        checkCompletedWithWrappedCancellationException(g);
2088 >        checkIncomplete(h);
2089 >        g.complete(1);
2090 >        checkCompletedWithWrappedCancellationException(h);
2091  
2092          f = new CompletableFuture<Integer>();
2093 <        f2 = new CompletableFuture<Integer>();
2094 <        g = f.thenCombineAsync(f2, add, new ThreadExecutor());
2095 <        f.complete(one);
2096 <        assertTrue(f2.cancel(true));
2097 <        checkCompletedWithWrappedCancellationException(g);
2093 >        g = new CompletableFuture<Integer>();
2094 >        h = f.thenCombineAsync(g, subtract, e);
2095 >        assertTrue(g.cancel(true));
2096 >        checkIncomplete(h);
2097 >        f.complete(3);
2098 >        checkCompletedWithWrappedCancellationException(h);
2099 >
2100 >        f = new CompletableFuture<Integer>();
2101 >        g = new CompletableFuture<Integer>();
2102 >        assertTrue(g.cancel(true));
2103 >        h = f.thenCombineAsync(g, subtract, e);
2104 >        checkIncomplete(h);
2105 >        f.complete(3);
2106 >        checkCompletedWithWrappedCancellationException(h);
2107 >
2108 >        f = new CompletableFuture<Integer>();
2109 >        g = new CompletableFuture<Integer>();
2110 >        assertTrue(f.cancel(true));
2111 >        assertTrue(g.cancel(true));
2112 >        h = f.thenCombineAsync(g, subtract, e);
2113 >        checkCompletedWithWrappedCancellationException(h);
2114 >
2115 >        assertEquals(0, e.count.get());
2116      }
2117  
2118      /**

Diff Legend

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