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.62 by jsr166, Fri Jun 6 01:19:22 2014 UTC vs.
Revision 1.63 by jsr166, Fri Jun 6 16:54:16 2014 UTC

# Line 415 | Line 415 | public class CompletableFutureTest exten
415          }
416      }
417  
418 <    class FailingSupplier extends CheckedAction implements Supplier<Integer>
418 >    class FailingSupplier extends CheckedAction
419 >        implements Supplier<Integer>
420      {
421          FailingSupplier(ExecutionMode m) { super(m); }
422          public Integer get() {
# Line 424 | Line 425 | public class CompletableFutureTest exten
425          }
426      }
427  
428 <    class FailingConsumer extends CheckedAction implements Consumer<Integer> {
428 >    class FailingConsumer extends CheckedIntegerAction
429 >        implements Consumer<Integer>
430 >    {
431          FailingConsumer(ExecutionMode m) { super(m); }
432          public void accept(Integer x) {
433              invoked();
434 +            value = x;
435              throw new CFException();
436          }
437      }
438  
439 <    class FailingBiConsumer extends CheckedAction
439 >    class FailingBiConsumer extends CheckedIntegerAction
440          implements BiConsumer<Integer, Integer>
441      {
442          FailingBiConsumer(ExecutionMode m) { super(m); }
443          public void accept(Integer x, Integer y) {
444              invoked();
445 +            value = subtract(x, y);
446              throw new CFException();
447          }
448      }
449  
450 <    class FailingFunction extends CheckedAction
450 >    class FailingFunction extends CheckedIntegerAction
451          implements Function<Integer, Integer>
452      {
453          FailingFunction(ExecutionMode m) { super(m); }
454          public Integer apply(Integer x) {
455              invoked();
456 +            value = x;
457              throw new CFException();
458          }
459      }
460  
461 <    class FailingBiFunction extends CheckedAction
461 >    class FailingBiFunction extends CheckedIntegerAction
462          implements BiFunction<Integer, Integer, Integer>
463      {
464          FailingBiFunction(ExecutionMode m) { super(m); }
465          public Integer apply(Integer x, Integer y) {
466              invoked();
467 +            value = subtract(x, y);
468              throw new CFException();
469          }
470      }
# Line 471 | Line 478 | public class CompletableFutureTest exten
478      }
479  
480  
481 <    class CompletableFutureInc extends CheckedAction
481 >    class CompletableFutureInc extends CheckedIntegerAction
482          implements Function<Integer, CompletableFuture<Integer>>
483      {
484          CompletableFutureInc(ExecutionMode m) { super(m); }
485          public CompletableFuture<Integer> apply(Integer x) {
486              invoked();
487 +            value = x;
488              CompletableFuture<Integer> f = new CompletableFuture<>();
489              f.complete(inc(x));
490              return f;
491          }
492      }
493  
494 <    class FailingCompletableFutureFunction extends CheckedAction
494 >    class FailingCompletableFutureFunction extends CheckedIntegerAction
495          implements Function<Integer, CompletableFuture<Integer>>
496      {
497          FailingCompletableFutureFunction(ExecutionMode m) { super(m); }
498          public CompletableFuture<Integer> apply(Integer x) {
499              invoked();
500 +            value = x;
501              throw new CFException();
502          }
503      }
# Line 1853 | Line 1862 | public class CompletableFutureTest exten
1862          f.complete(v1);
1863          final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1864          final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1856 –        g.complete(v2);
1857 –        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1858 –        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1859 –        
1860 –        checkCompletedNormally(f, v1);
1861 –        checkCompletedNormally(g, v2);
1865          checkCompletedWithWrappedCFException(h0);
1866          checkCompletedWithWrappedCFException(h1);
1867          checkCompletedWithWrappedCFException(h2);
1868          checkCompletedWithWrappedCFException(h3);
1869 <        checkCompletedWithWrappedCFException(h4);
1867 <        checkCompletedWithWrappedCFException(h5);
1868 <        for (int i = 0; i < rs.length; i++) rs[i].assertInvoked();
1869 <    }}
1869 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
1870  
1871 –    /**
1872 –     * acceptEither result completes normally after normal completion
1873 –     * of either source
1874 –     */
1875 –    public void testAcceptEither_normalCompletion1() {
1876 –        for (ExecutionMode m : ExecutionMode.values())
1877 –        for (Integer v1 : new Integer[] { 1, null })
1878 –        for (Integer v2 : new Integer[] { 2, null })
1879 –    {
1880 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1881 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1882 –        final IncAction r = new IncAction(m);
1883 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1884 –
1885 –        f.complete(v1);
1886 –        checkCompletedNormally(h, null);
1887 –        assertEquals(inc(v1), r.value);
1871          g.complete(v2);
1872  
1873 <        checkCompletedNormally(f, v1);
1874 <        checkCompletedNormally(g, v2);
1875 <        checkCompletedNormally(h, null);
1893 <    }}
1894 <
1895 <    public void testAcceptEither_normalCompletion2() {
1896 <        for (ExecutionMode m : ExecutionMode.values())
1897 <        for (Integer v1 : new Integer[] { 1, null })
1898 <        for (Integer v2 : new Integer[] { 2, null })
1899 <    {
1900 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1901 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1902 <        final IncAction r = new IncAction(m);
1903 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1873 >        // unspecified behavior - both source completions available
1874 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1875 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1876  
1877 <        g.complete(v2);
1878 <        checkCompletedNormally(h, null);
1879 <        assertEquals(inc(v2), r.value);
1880 <        f.complete(v1);
1877 >        checkCompletedWithWrappedCFException(h4);
1878 >        assertTrue(Objects.equals(v1, rs[4].value) ||
1879 >                   Objects.equals(v2, rs[4].value));
1880 >        checkCompletedWithWrappedCFException(h5);
1881 >        assertTrue(Objects.equals(v1, rs[5].value) ||
1882 >                   Objects.equals(v2, rs[5].value));
1883  
1884          checkCompletedNormally(f, v1);
1885          checkCompletedNormally(g, v2);
1912 –        checkCompletedNormally(h, null);
1886      }}
1887  
1888 <    public void testAcceptEither_normalCompletion3() {
1888 >    /**
1889 >     * acceptEither result completes normally after normal completion
1890 >     * of either source
1891 >     */
1892 >    public void testAcceptEither_normalCompletion() {
1893          for (ExecutionMode m : ExecutionMode.values())
1894          for (Integer v1 : new Integer[] { 1, null })
1895          for (Integer v2 : new Integer[] { 2, null })
1896      {
1897          final CompletableFuture<Integer> f = new CompletableFuture<>();
1898          final CompletableFuture<Integer> g = new CompletableFuture<>();
1899 <        final IncAction r = new IncAction(m);
1899 >        final IncAction[] rs = new IncAction[6];
1900 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
1901  
1902 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
1903 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
1904 +        checkIncomplete(h0);
1905 +        checkIncomplete(h1);
1906 +        rs[0].assertNotInvoked();
1907 +        rs[1].assertNotInvoked();
1908          f.complete(v1);
1909 +        checkCompletedNormally(h0, null);
1910 +        checkCompletedNormally(h1, null);
1911 +        rs[0].assertValue(inc(v1));
1912 +        rs[1].assertValue(inc(v1));
1913 +        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
1914 +        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
1915 +        checkCompletedNormally(h2, null);
1916 +        checkCompletedNormally(h3, null);
1917 +        rs[2].assertValue(inc(v1));
1918 +        rs[3].assertValue(inc(v1));
1919          g.complete(v2);
1926 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1920  
1921 <        checkCompletedNormally(h, null);
1921 >        // unspecified behavior - both source completions available
1922 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
1923 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
1924 >        checkCompletedNormally(h4, null);
1925 >        checkCompletedNormally(h5, null);
1926 >        assertTrue(Objects.equals(inc(v1), rs[4].value) ||
1927 >                   Objects.equals(inc(v2), rs[4].value));
1928 >        assertTrue(Objects.equals(inc(v1), rs[5].value) ||
1929 >                   Objects.equals(inc(v2), rs[5].value));
1930 >
1931          checkCompletedNormally(f, v1);
1932          checkCompletedNormally(g, v2);
1933 <
1934 <        // unspecified behavior
1935 <        assertTrue(Objects.equals(r.value, inc(v1)) ||
1936 <                   Objects.equals(r.value, inc(v2)));
1933 >        checkCompletedNormally(h0, null);
1934 >        checkCompletedNormally(h1, null);
1935 >        checkCompletedNormally(h2, null);
1936 >        checkCompletedNormally(h3, null);
1937 >        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
1938      }}
1939  
1940      /**
1941       * acceptEither result completes exceptionally after exceptional
1942       * completion of either source
1943       */
1944 <    public void testAcceptEither_exceptionalCompletion1() {
1944 >    public void testAcceptEither_exceptionalCompletion() {
1945          for (ExecutionMode m : ExecutionMode.values())
1946          for (Integer v1 : new Integer[] { 1, null })
1947      {
1948          final CompletableFuture<Integer> f = new CompletableFuture<>();
1949          final CompletableFuture<Integer> g = new CompletableFuture<>();
1947 –        final IncAction r = new IncAction(m);
1948 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1950          final CFException ex = new CFException();
1951 +        final IncAction[] rs = new IncAction[6];
1952 +        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
1953  
1954 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
1955 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
1956 +        checkIncomplete(h0);
1957 +        checkIncomplete(h1);
1958 +        rs[0].assertNotInvoked();
1959 +        rs[1].assertNotInvoked();
1960          f.completeExceptionally(ex);
1961 <        checkCompletedWithWrappedCFException(h, ex);
1962 <        g.complete(v1);
1963 <
1964 <        r.assertNotInvoked();
1965 <        checkCompletedNormally(g, v1);
1966 <        checkCompletedWithWrappedCFException(f, ex);
1958 <        checkCompletedWithWrappedCFException(h, ex);
1959 <    }}
1960 <
1961 <    public void testAcceptEither_exceptionalCompletion2() {
1962 <        for (ExecutionMode m : ExecutionMode.values())
1963 <        for (Integer v1 : new Integer[] { 1, null })
1964 <    {
1965 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1966 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1967 <        final IncAction r = new IncAction(m);
1968 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1969 <        final CFException ex = new CFException();
1970 <
1971 <        g.completeExceptionally(ex);
1972 <        checkCompletedWithWrappedCFException(h, ex);
1973 <        f.complete(v1);
1974 <
1975 <        r.assertNotInvoked();
1976 <        checkCompletedNormally(f, v1);
1977 <        checkCompletedWithWrappedCFException(g, ex);
1978 <        checkCompletedWithWrappedCFException(h, ex);
1979 <    }}
1980 <
1981 <    public void testAcceptEither_exceptionalCompletion3() {
1982 <        for (ExecutionMode m : ExecutionMode.values())
1983 <        for (Integer v1 : new Integer[] { 1, null })
1984 <    {
1985 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1986 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1987 <        final IncAction r = new IncAction(m);
1988 <        final CFException ex = new CFException();
1961 >        checkCompletedWithWrappedCFException(h0, ex);
1962 >        checkCompletedWithWrappedCFException(h1, ex);
1963 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
1964 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
1965 >        checkCompletedWithWrappedCFException(h2, ex);
1966 >        checkCompletedWithWrappedCFException(h3, ex);
1967  
1968 <        g.completeExceptionally(ex);
1991 <        f.complete(v1);
1992 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1968 >        g.complete(v1);
1969  
1970 <        // unspecified behavior
1971 <        Integer v;
1970 >        // unspecified behavior - both source completions available
1971 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
1972 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
1973          try {
1974 <            assertNull(h.join());
1975 <            r.assertInvoked();
1999 <            assertEquals(inc(v1), r.value);
1974 >            assertNull(h4.join());
1975 >            rs[4].assertValue(inc(v1));
1976          } catch (CompletionException ok) {
1977 <            checkCompletedWithWrappedCFException(h, ex);
1978 <            r.assertNotInvoked();
1977 >            checkCompletedWithWrappedCFException(h4, ex);
1978 >            rs[4].assertNotInvoked();
1979          }
2004 –
2005 –        checkCompletedWithWrappedCFException(g, ex);
2006 –        checkCompletedNormally(f, v1);
2007 –    }}
2008 –
2009 –    public void testAcceptEither_exceptionalCompletion4() {
2010 –        for (ExecutionMode m : ExecutionMode.values())
2011 –        for (Integer v1 : new Integer[] { 1, null })
2012 –    {
2013 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2014 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2015 –        final IncAction r = new IncAction(m);
2016 –        final CFException ex = new CFException();
2017 –
2018 –        f.completeExceptionally(ex);
2019 –        g.complete(v1);
2020 –        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2021 –
2022 –        // unspecified behavior
2023 –        Integer v;
1980          try {
1981 <            assertNull(h.join());
1982 <            r.assertInvoked();
2027 <            assertEquals(inc(v1), r.value);
1981 >            assertNull(h5.join());
1982 >            rs[5].assertValue(inc(v1));
1983          } catch (CompletionException ok) {
1984 <            checkCompletedWithWrappedCFException(h, ex);
1985 <            r.assertNotInvoked();
1984 >            checkCompletedWithWrappedCFException(h5, ex);
1985 >            rs[5].assertNotInvoked();
1986          }
1987  
1988          checkCompletedWithWrappedCFException(f, ex);
1989          checkCompletedNormally(g, v1);
1990 <    }}
1991 <
1992 <    /**
1993 <     * acceptEither result completes exceptionally if action does
1994 <     */
1995 <    public void testAcceptEither_actionFailed1() {
2041 <        for (ExecutionMode m : ExecutionMode.values())
2042 <        for (Integer v1 : new Integer[] { 1, null })
2043 <        for (Integer v2 : new Integer[] { 2, null })
2044 <    {
2045 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2046 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2047 <        final FailingConsumer r = new FailingConsumer(m);
2048 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2049 <
2050 <        f.complete(v1);
2051 <        checkCompletedWithWrappedCFException(h);
2052 <        g.complete(v2);
2053 <        checkCompletedNormally(f, v1);
2054 <        checkCompletedNormally(g, v2);
2055 <    }}
2056 <
2057 <    public void testAcceptEither_actionFailed2() {
2058 <        for (ExecutionMode m : ExecutionMode.values())
2059 <        for (Integer v1 : new Integer[] { 1, null })
2060 <        for (Integer v2 : new Integer[] { 2, null })
2061 <    {
2062 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2063 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2064 <        final FailingConsumer r = new FailingConsumer(m);
2065 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2066 <
2067 <        g.complete(v2);
2068 <        checkCompletedWithWrappedCFException(h);
2069 <        f.complete(v1);
2070 <        checkCompletedNormally(f, v1);
2071 <        checkCompletedNormally(g, v2);
1990 >        checkCompletedWithWrappedCFException(h0, ex);
1991 >        checkCompletedWithWrappedCFException(h1, ex);
1992 >        checkCompletedWithWrappedCFException(h2, ex);
1993 >        checkCompletedWithWrappedCFException(h3, ex);
1994 >        checkCompletedWithWrappedCFException(h4, ex);
1995 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1996      }}
1997  
1998      /**
1999       * acceptEither result completes exceptionally if either source cancelled
2000       */
2001 <    public void testAcceptEither_sourceCancelled1() {
2001 >    public void testAcceptEither_sourceCancelled() {
2002          for (ExecutionMode m : ExecutionMode.values())
2003          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2004          for (Integer v1 : new Integer[] { 1, null })
2005      {
2006          final CompletableFuture<Integer> f = new CompletableFuture<>();
2007          final CompletableFuture<Integer> g = new CompletableFuture<>();
2008 <        final IncAction r = new IncAction(m);
2009 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2008 >        final IncAction[] rs = new IncAction[6];
2009 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
2010 >
2011 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2012 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2013 >        checkIncomplete(h0);
2014 >        checkIncomplete(h1);
2015 >        rs[0].assertNotInvoked();
2016 >        rs[1].assertNotInvoked();
2017 >        f.cancel(mayInterruptIfRunning);
2018 >        checkCompletedWithWrappedCancellationException(h0);
2019 >        checkCompletedWithWrappedCancellationException(h1);
2020 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2021 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2022 >        checkCompletedWithWrappedCancellationException(h2);
2023 >        checkCompletedWithWrappedCancellationException(h3);
2024  
2087 –        assertTrue(f.cancel(mayInterruptIfRunning));
2088 –        checkCompletedWithWrappedCancellationException(h);
2025          g.complete(v1);
2026  
2027 +        // unspecified behavior - both source completions available
2028 +        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2029 +        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2030 +        try {
2031 +            assertNull(h4.join());
2032 +            rs[4].assertValue(inc(v1));
2033 +        } catch (CompletionException ok) {
2034 +            checkCompletedWithWrappedCancellationException(h4);
2035 +            rs[4].assertNotInvoked();
2036 +        }
2037 +        try {
2038 +            assertNull(h5.join());
2039 +            rs[5].assertValue(inc(v1));
2040 +        } catch (CompletionException ok) {
2041 +            checkCompletedWithWrappedCancellationException(h5);
2042 +            rs[5].assertNotInvoked();
2043 +        }
2044 +
2045          checkCancelled(f);
2092 –        r.assertNotInvoked();
2046          checkCompletedNormally(g, v1);
2047 <        checkCompletedWithWrappedCancellationException(h);
2047 >        checkCompletedWithWrappedCancellationException(h0);
2048 >        checkCompletedWithWrappedCancellationException(h1);
2049 >        checkCompletedWithWrappedCancellationException(h2);
2050 >        checkCompletedWithWrappedCancellationException(h3);
2051 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2052      }}
2053  
2054 <    public void testAcceptEither_sourceCancelled2() {
2054 >    /**
2055 >     * acceptEither result completes exceptionally if action does
2056 >     */
2057 >    public void testAcceptEither_actionFailed() {
2058          for (ExecutionMode m : ExecutionMode.values())
2099 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2059          for (Integer v1 : new Integer[] { 1, null })
2060 +        for (Integer v2 : new Integer[] { 2, null })
2061      {
2062          final CompletableFuture<Integer> f = new CompletableFuture<>();
2063          final CompletableFuture<Integer> g = new CompletableFuture<>();
2064 <        final IncAction r = new IncAction(m);
2065 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2064 >        final FailingConsumer[] rs = new FailingConsumer[6];
2065 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
2066  
2067 <        assertTrue(g.cancel(mayInterruptIfRunning));
2068 <        checkCompletedWithWrappedCancellationException(h);
2067 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2068 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2069          f.complete(v1);
2070 +        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2071 +        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2072 +        checkCompletedWithWrappedCFException(h0);
2073 +        checkCompletedWithWrappedCFException(h1);
2074 +        checkCompletedWithWrappedCFException(h2);
2075 +        checkCompletedWithWrappedCFException(h3);
2076 +        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2077  
2078 <        checkCancelled(g);
2112 <        r.assertNotInvoked();
2113 <        checkCompletedNormally(f, v1);
2114 <        checkCompletedWithWrappedCancellationException(h);
2115 <    }}
2116 <
2117 <    public void testAcceptEither_sourceCancelled3() {
2118 <        for (ExecutionMode m : ExecutionMode.values())
2119 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2120 <        for (Integer v1 : new Integer[] { 1, null })
2121 <    {
2122 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2123 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2124 <        final IncAction r = new IncAction(m);
2078 >        g.complete(v2);
2079  
2080 <        assertTrue(g.cancel(mayInterruptIfRunning));
2081 <        f.complete(v1);
2082 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2080 >        // unspecified behavior - both source completions available
2081 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2082 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2083  
2084 <        // unspecified behavior
2085 <        Integer v;
2086 <        try {
2087 <            assertNull(h.join());
2088 <            r.assertInvoked();
2089 <            assertEquals(inc(v1), r.value);
2136 <        } catch (CompletionException ok) {
2137 <            checkCompletedWithWrappedCancellationException(h);
2138 <            r.assertNotInvoked();
2139 <        }
2084 >        checkCompletedWithWrappedCFException(h4);
2085 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2086 >                   Objects.equals(v2, rs[4].value));
2087 >        checkCompletedWithWrappedCFException(h5);
2088 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2089 >                   Objects.equals(v2, rs[5].value));
2090  
2141 –        checkCancelled(g);
2091          checkCompletedNormally(f, v1);
2092 <    }}
2144 <
2145 <    public void testAcceptEither_sourceCancelled4() {
2146 <        for (ExecutionMode m : ExecutionMode.values())
2147 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2148 <        for (Integer v1 : new Integer[] { 1, null })
2149 <    {
2150 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2151 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2152 <        final IncAction r = new IncAction(m);
2153 <
2154 <        assertTrue(f.cancel(mayInterruptIfRunning));
2155 <        g.complete(v1);
2156 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2157 <
2158 <        // unspecified behavior
2159 <        Integer v;
2160 <        try {
2161 <            assertNull(h.join());
2162 <            r.assertInvoked();
2163 <            assertEquals(inc(v1), r.value);
2164 <        } catch (CompletionException ok) {
2165 <            checkCompletedWithWrappedCancellationException(h);
2166 <            r.assertNotInvoked();
2167 <        }
2168 <
2169 <        checkCancelled(f);
2170 <        checkCompletedNormally(g, v1);
2092 >        checkCompletedNormally(g, v2);
2093      }}
2094  
2095      /**

Diff Legend

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