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.19 by jsr166, Sun Apr 7 15:04:14 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 1268 | Line 1314 | public class CompletableFutureTest exten
1314          assertTrue(f.cancel(true));
1315          checkCompletedWithWrappedCancellationException(g);
1316      }
1317 +
1318      /**
1319       * thenCombineAsync result completes normally after normal
1320       * completion of sources
1321       */
1322      public void testThenCombineAsync() {
1323 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1324 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1325 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1326 <        f.complete(one);
1327 <        checkIncomplete(g);
1328 <        f2.complete(two);
1329 <        checkCompletedNormally(g, three);
1323 >        CompletableFuture<Integer> f, g, h;
1324 >
1325 >        f = new CompletableFuture<Integer>();
1326 >        g = new CompletableFuture<Integer>();
1327 >        h = f.thenCombineAsync(g, subtract);
1328 >        f.complete(3);
1329 >        checkIncomplete(h);
1330 >        g.complete(1);
1331 >        checkCompletedNormally(h, 2);
1332 >
1333 >        f = new CompletableFuture<Integer>();
1334 >        g = new CompletableFuture<Integer>();
1335 >        h = f.thenCombineAsync(g, subtract);
1336 >        g.complete(1);
1337 >        checkIncomplete(h);
1338 >        f.complete(3);
1339 >        checkCompletedNormally(h, 2);
1340 >
1341 >        f = new CompletableFuture<Integer>();
1342 >        g = new CompletableFuture<Integer>();
1343 >        g.complete(1);
1344 >        f.complete(3);
1345 >        h = f.thenCombineAsync(g, subtract);
1346 >        checkCompletedNormally(h, 2);
1347      }
1348  
1349      /**
1350       * thenCombineAsync result completes exceptionally after exceptional
1351 <     * completion of source
1351 >     * completion of either source
1352       */
1353      public void testThenCombineAsync2() {
1354 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1355 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1356 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1354 >        CompletableFuture<Integer> f, g, h;
1355 >
1356 >        f = new CompletableFuture<Integer>();
1357 >        g = new CompletableFuture<Integer>();
1358 >        h = f.thenCombineAsync(g, subtract);
1359          f.completeExceptionally(new CFException());
1360 <        f2.complete(two);
1361 <        checkCompletedWithWrappedCFException(g);
1360 >        checkIncomplete(h);
1361 >        g.complete(1);
1362 >        checkCompletedWithWrappedCFException(h);
1363  
1364          f = new CompletableFuture<Integer>();
1365 <        f2 = new CompletableFuture<Integer>();
1366 <        g = f.thenCombineAsync(f2, add);
1367 <        f.complete(one);
1368 <        f2.completeExceptionally(new CFException());
1369 <        checkCompletedWithWrappedCFException(g);
1365 >        g = new CompletableFuture<Integer>();
1366 >        h = f.thenCombineAsync(g, subtract);
1367 >        g.completeExceptionally(new CFException());
1368 >        checkIncomplete(h);
1369 >        f.complete(3);
1370 >        checkCompletedWithWrappedCFException(h);
1371 >
1372 >        f = new CompletableFuture<Integer>();
1373 >        g = new CompletableFuture<Integer>();
1374 >        g.completeExceptionally(new CFException());
1375 >        f.complete(3);
1376 >        h = f.thenCombineAsync(g, subtract);
1377 >        checkCompletedWithWrappedCFException(h);
1378      }
1379  
1380      /**
# Line 1312 | Line 1387 | public class CompletableFutureTest exten
1387          CompletableFuture<Integer> g = f.thenCombineAsync(f2, r);
1388          f.complete(one);
1389          checkIncomplete(g);
1390 +        assertFalse(r.ran);
1391          f2.complete(two);
1392          checkCompletedWithWrappedCFException(g);
1393 +        assertTrue(r.ran);
1394      }
1395  
1396      /**
1397       * thenCombineAsync result completes exceptionally if either source cancelled
1398       */
1399      public void testThenCombineAsync4() {
1400 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1401 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1402 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add);
1400 >        CompletableFuture<Integer> f, g, h;
1401 >
1402 >        f = new CompletableFuture<Integer>();
1403 >        g = new CompletableFuture<Integer>();
1404 >        h = f.thenCombineAsync(g, subtract);
1405          assertTrue(f.cancel(true));
1406 <        f2.complete(two);
1407 <        checkCompletedWithWrappedCancellationException(g);
1406 >        checkIncomplete(h);
1407 >        g.complete(1);
1408 >        checkCompletedWithWrappedCancellationException(h);
1409  
1410          f = new CompletableFuture<Integer>();
1411 <        f2 = new CompletableFuture<Integer>();
1412 <        g = f.thenCombineAsync(f2, add);
1413 <        f.complete(one);
1414 <        assertTrue(f2.cancel(true));
1415 <        checkCompletedWithWrappedCancellationException(g);
1411 >        g = new CompletableFuture<Integer>();
1412 >        h = f.thenCombineAsync(g, subtract);
1413 >        assertTrue(g.cancel(true));
1414 >        checkIncomplete(h);
1415 >        f.complete(3);
1416 >        checkCompletedWithWrappedCancellationException(h);
1417 >
1418 >        f = new CompletableFuture<Integer>();
1419 >        g = new CompletableFuture<Integer>();
1420 >        g.complete(3);
1421 >        assertTrue(f.cancel(true));
1422 >        h = f.thenCombineAsync(g, subtract);
1423 >        checkCompletedWithWrappedCancellationException(h);
1424 >
1425 >        f = new CompletableFuture<Integer>();
1426 >        g = new CompletableFuture<Integer>();
1427 >        f.complete(3);
1428 >        assertTrue(g.cancel(true));
1429 >        h = f.thenCombineAsync(g, subtract);
1430 >        checkCompletedWithWrappedCancellationException(h);
1431      }
1432  
1433      /**
# Line 1891 | Line 1986 | public class CompletableFutureTest exten
1986          assertTrue(f.cancel(true));
1987          checkCompletedWithWrappedCancellationException(g);
1988      }
1989 +
1990      /**
1991       * thenCombineAsync result completes normally after normal
1992       * completion of sources
1993       */
1994      public void testThenCombineAsyncE() {
1995 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
1996 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
1997 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
1998 <        f.complete(one);
1999 <        checkIncomplete(g);
2000 <        f2.complete(two);
2001 <        checkCompletedNormally(g, three);
1995 >        CompletableFuture<Integer> f, g, h;
1996 >        ThreadExecutor e = new ThreadExecutor();
1997 >        int count = 0;
1998 >
1999 >        f = new CompletableFuture<Integer>();
2000 >        g = new CompletableFuture<Integer>();
2001 >        h = f.thenCombineAsync(g, subtract, e);
2002 >        f.complete(3);
2003 >        checkIncomplete(h);
2004 >        g.complete(1);
2005 >        checkCompletedNormally(h, 2);
2006 >        assertEquals(++count, e.count.get());
2007 >
2008 >        f = new CompletableFuture<Integer>();
2009 >        g = new CompletableFuture<Integer>();
2010 >        h = f.thenCombineAsync(g, subtract, e);
2011 >        g.complete(1);
2012 >        checkIncomplete(h);
2013 >        f.complete(3);
2014 >        checkCompletedNormally(h, 2);
2015 >        assertEquals(++count, e.count.get());
2016 >
2017 >        f = new CompletableFuture<Integer>();
2018 >        g = new CompletableFuture<Integer>();
2019 >        g.complete(1);
2020 >        f.complete(3);
2021 >        h = f.thenCombineAsync(g, subtract, e);
2022 >        checkCompletedNormally(h, 2);
2023 >        assertEquals(++count, e.count.get());
2024      }
2025  
2026      /**
2027       * thenCombineAsync result completes exceptionally after exceptional
2028 <     * completion of source
2028 >     * completion of either source
2029       */
2030      public void testThenCombineAsync2E() {
2031 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2032 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2033 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
2031 >        CompletableFuture<Integer> f, g, h;
2032 >        ThreadExecutor e = new ThreadExecutor();
2033 >        int count = 0;
2034 >
2035 >        f = new CompletableFuture<Integer>();
2036 >        g = new CompletableFuture<Integer>();
2037 >        h = f.thenCombineAsync(g, subtract, e);
2038          f.completeExceptionally(new CFException());
2039 <        f2.complete(two);
2040 <        checkCompletedWithWrappedCFException(g);
2039 >        checkIncomplete(h);
2040 >        g.complete(1);
2041 >        checkCompletedWithWrappedCFException(h);
2042  
2043          f = new CompletableFuture<Integer>();
2044 <        f2 = new CompletableFuture<Integer>();
2045 <        g = f.thenCombineAsync(f2, add, new ThreadExecutor());
2046 <        f.complete(one);
2047 <        f2.completeExceptionally(new CFException());
2048 <        checkCompletedWithWrappedCFException(g);
2044 >        g = new CompletableFuture<Integer>();
2045 >        h = f.thenCombineAsync(g, subtract, e);
2046 >        g.completeExceptionally(new CFException());
2047 >        checkIncomplete(h);
2048 >        f.complete(3);
2049 >        checkCompletedWithWrappedCFException(h);
2050 >
2051 >        f = new CompletableFuture<Integer>();
2052 >        g = new CompletableFuture<Integer>();
2053 >        g.completeExceptionally(new CFException());
2054 >        h = f.thenCombineAsync(g, subtract, e);
2055 >        checkIncomplete(h);
2056 >        f.complete(3);
2057 >        checkCompletedWithWrappedCFException(h);
2058 >
2059 >        assertEquals(0, e.count.get());
2060      }
2061  
2062      /**
# Line 1935 | Line 2069 | public class CompletableFutureTest exten
2069          CompletableFuture<Integer> g = f.thenCombineAsync(f2, r, new ThreadExecutor());
2070          f.complete(one);
2071          checkIncomplete(g);
2072 +        assertFalse(r.ran);
2073          f2.complete(two);
2074          checkCompletedWithWrappedCFException(g);
2075 +        assertTrue(r.ran);
2076      }
2077  
2078      /**
2079       * thenCombineAsync result completes exceptionally if either source cancelled
2080       */
2081      public void testThenCombineAsync4E() {
2082 <        CompletableFuture<Integer> f = new CompletableFuture<Integer>();
2083 <        CompletableFuture<Integer> f2 = new CompletableFuture<Integer>();
2084 <        CompletableFuture<Integer> g = f.thenCombineAsync(f2, add, new ThreadExecutor());
2082 >        CompletableFuture<Integer> f, g, h;
2083 >        ThreadExecutor e = new ThreadExecutor();
2084 >
2085 >        f = new CompletableFuture<Integer>();
2086 >        g = new CompletableFuture<Integer>();
2087 >        h = f.thenCombineAsync(g, subtract, e);
2088          assertTrue(f.cancel(true));
2089 <        f2.complete(two);
2090 <        checkCompletedWithWrappedCancellationException(g);
2089 >        checkIncomplete(h);
2090 >        g.complete(1);
2091 >        checkCompletedWithWrappedCancellationException(h);
2092  
2093          f = new CompletableFuture<Integer>();
2094 <        f2 = new CompletableFuture<Integer>();
2095 <        g = f.thenCombineAsync(f2, add, new ThreadExecutor());
2096 <        f.complete(one);
2097 <        assertTrue(f2.cancel(true));
2098 <        checkCompletedWithWrappedCancellationException(g);
2094 >        g = new CompletableFuture<Integer>();
2095 >        h = f.thenCombineAsync(g, subtract, e);
2096 >        assertTrue(g.cancel(true));
2097 >        checkIncomplete(h);
2098 >        f.complete(3);
2099 >        checkCompletedWithWrappedCancellationException(h);
2100 >
2101 >        f = new CompletableFuture<Integer>();
2102 >        g = new CompletableFuture<Integer>();
2103 >        assertTrue(g.cancel(true));
2104 >        h = f.thenCombineAsync(g, subtract, e);
2105 >        checkIncomplete(h);
2106 >        f.complete(3);
2107 >        checkCompletedWithWrappedCancellationException(h);
2108 >
2109 >        f = new CompletableFuture<Integer>();
2110 >        g = new CompletableFuture<Integer>();
2111 >        assertTrue(f.cancel(true));
2112 >        assertTrue(g.cancel(true));
2113 >        h = f.thenCombineAsync(g, subtract, e);
2114 >        checkCompletedWithWrappedCancellationException(h);
2115 >
2116 >        assertEquals(0, e.count.get());
2117      }
2118  
2119      /**

Diff Legend

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