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.63 by jsr166, Fri Jun 6 16:54:16 2014 UTC vs.
Revision 1.68 by jsr166, Fri Jun 6 19:35:54 2014 UTC

# Line 360 | Line 360 | public class CompletableFutureTest exten
360          return (x == null) ? null : x + 1;
361      }
362  
363 <    class IncAction extends CheckedIntegerAction
363 >    class NoopConsumer extends CheckedIntegerAction
364          implements Consumer<Integer>
365      {
366 <        IncAction(ExecutionMode m) { super(m); }
366 >        NoopConsumer(ExecutionMode m) { super(m); }
367          public void accept(Integer x) {
368              invoked();
369 <            value = inc(x);
369 >            value = x;
370          }
371      }
372  
# Line 1249 | Line 1249 | public class CompletableFutureTest exten
1249          for (Integer v1 : new Integer[] { 1, null })
1250      {
1251          final CompletableFuture<Integer> f = new CompletableFuture<>();
1252 <        final IncAction r = new IncAction(m);
1252 >        final NoopConsumer r = new NoopConsumer(m);
1253          if (!createIncomplete) f.complete(v1);
1254          final CompletableFuture<Void> g = m.thenAccept(f, r);
1255          if (createIncomplete) {
# Line 1258 | Line 1258 | public class CompletableFutureTest exten
1258          }
1259  
1260          checkCompletedNormally(g, null);
1261 +        r.assertValue(v1);
1262          checkCompletedNormally(f, v1);
1262 –        r.assertInvoked();
1263 –        r.assertValue(inc(v1));
1263      }}
1264  
1265      /**
# Line 1273 | Line 1272 | public class CompletableFutureTest exten
1272      {
1273          final CFException ex = new CFException();
1274          final CompletableFuture<Integer> f = new CompletableFuture<>();
1275 <        final IncAction r = new IncAction(m);
1275 >        final NoopConsumer r = new NoopConsumer(m);
1276          if (!createIncomplete) f.completeExceptionally(ex);
1277          final CompletableFuture<Void> g = m.thenAccept(f, r);
1278          if (createIncomplete) {
# Line 1295 | Line 1294 | public class CompletableFutureTest exten
1294          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1295      {
1296          final CompletableFuture<Integer> f = new CompletableFuture<>();
1297 <        final IncAction r = new IncAction(m);
1297 >        final NoopConsumer r = new NoopConsumer(m);
1298          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1299          final CompletableFuture<Void> g = m.thenAccept(f, r);
1300          if (createIncomplete) {
# Line 1766 | Line 1765 | public class CompletableFutureTest exten
1765          final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1766          try {
1767              assertEquals(inc(v1), h4.join());
1768 <            rs[4].assertInvoked();
1768 >            rs[4].assertValue(inc(v1));
1769          } catch (CompletionException ok) {
1770              checkCompletedWithWrappedCFException(h4, ex);
1771              rs[4].assertNotInvoked();
1772          }
1773          try {
1774              assertEquals(inc(v1), h5.join());
1775 <            rs[5].assertInvoked();
1775 >            rs[5].assertValue(inc(v1));
1776          } catch (CompletionException ok) {
1777              checkCompletedWithWrappedCFException(h5, ex);
1778              rs[5].assertNotInvoked();
# Line 1789 | Line 1788 | public class CompletableFutureTest exten
1788          for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1789      }}
1790  
1791 +    public void testApplyToEither_exceptionalCompletion2() {
1792 +        for (ExecutionMode m : ExecutionMode.values())
1793 +        for (boolean fFirst : new boolean[] { true, false })
1794 +        for (Integer v1 : new Integer[] { 1, null })
1795 +    {
1796 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1797 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1798 +        final CFException ex = new CFException();
1799 +        final IncFunction[] rs = new IncFunction[6];
1800 +        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1801 +
1802 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1803 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1804 +        if (fFirst) {
1805 +            f.complete(v1);
1806 +            g.completeExceptionally(ex);
1807 +        } else {
1808 +            g.completeExceptionally(ex);
1809 +            f.complete(v1);
1810 +        }
1811 +        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1812 +        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1813 +
1814 +        // unspecified behavior - both source completions available
1815 +        try {
1816 +            assertEquals(inc(v1), h0.join());
1817 +            rs[0].assertValue(inc(v1));
1818 +        } catch (CompletionException ok) {
1819 +            checkCompletedWithWrappedCFException(h0, ex);
1820 +            rs[0].assertNotInvoked();
1821 +        }
1822 +        try {
1823 +            assertEquals(inc(v1), h1.join());
1824 +            rs[1].assertValue(inc(v1));
1825 +        } catch (CompletionException ok) {
1826 +            checkCompletedWithWrappedCFException(h1, ex);
1827 +            rs[1].assertNotInvoked();
1828 +        }
1829 +        try {
1830 +            assertEquals(inc(v1), h2.join());
1831 +            rs[2].assertValue(inc(v1));
1832 +        } catch (CompletionException ok) {
1833 +            checkCompletedWithWrappedCFException(h2, ex);
1834 +            rs[2].assertNotInvoked();
1835 +        }
1836 +        try {
1837 +            assertEquals(inc(v1), h3.join());
1838 +            rs[3].assertValue(inc(v1));
1839 +        } catch (CompletionException ok) {
1840 +            checkCompletedWithWrappedCFException(h3, ex);
1841 +            rs[3].assertNotInvoked();
1842 +        }
1843 +
1844 +        checkCompletedNormally(f, v1);
1845 +        checkCompletedWithWrappedCFException(g, ex);
1846 +    }}
1847 +
1848      /**
1849       * applyToEither result completes exceptionally if either source cancelled
1850       */
# Line 1822 | Line 1878 | public class CompletableFutureTest exten
1878          final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1879          try {
1880              assertEquals(inc(v1), h4.join());
1881 <            rs[4].assertInvoked();
1881 >            rs[4].assertValue(inc(v1));
1882          } catch (CompletionException ok) {
1883              checkCompletedWithWrappedCancellationException(h4);
1884              rs[4].assertNotInvoked();
1885          }
1886          try {
1887              assertEquals(inc(v1), h5.join());
1888 <            rs[5].assertInvoked();
1888 >            rs[5].assertValue(inc(v1));
1889          } catch (CompletionException ok) {
1890              checkCompletedWithWrappedCancellationException(h5);
1891              rs[5].assertNotInvoked();
# Line 1844 | Line 1900 | public class CompletableFutureTest exten
1900          for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1901      }}
1902  
1903 +    public void testApplyToEither_sourceCancelled2() {
1904 +        for (ExecutionMode m : ExecutionMode.values())
1905 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1906 +        for (boolean fFirst : new boolean[] { true, false })
1907 +        for (Integer v1 : new Integer[] { 1, null })
1908 +    {
1909 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1910 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1911 +        final IncFunction[] rs = new IncFunction[6];
1912 +        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1913 +
1914 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1915 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1916 +        if (fFirst) {
1917 +            f.complete(v1);
1918 +            g.cancel(mayInterruptIfRunning);
1919 +        } else {
1920 +            g.cancel(mayInterruptIfRunning);
1921 +            f.complete(v1);
1922 +        }
1923 +        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1924 +        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1925 +
1926 +        // unspecified behavior - both source completions available
1927 +        try {
1928 +            assertEquals(inc(v1), h0.join());
1929 +            rs[0].assertValue(inc(v1));
1930 +        } catch (CompletionException ok) {
1931 +            checkCompletedWithWrappedCancellationException(h0);
1932 +            rs[0].assertNotInvoked();
1933 +        }
1934 +        try {
1935 +            assertEquals(inc(v1), h1.join());
1936 +            rs[1].assertValue(inc(v1));
1937 +        } catch (CompletionException ok) {
1938 +            checkCompletedWithWrappedCancellationException(h1);
1939 +            rs[1].assertNotInvoked();
1940 +        }
1941 +        try {
1942 +            assertEquals(inc(v1), h2.join());
1943 +            rs[2].assertValue(inc(v1));
1944 +        } catch (CompletionException ok) {
1945 +            checkCompletedWithWrappedCancellationException(h2);
1946 +            rs[2].assertNotInvoked();
1947 +        }
1948 +        try {
1949 +            assertEquals(inc(v1), h3.join());
1950 +            rs[3].assertValue(inc(v1));
1951 +        } catch (CompletionException ok) {
1952 +            checkCompletedWithWrappedCancellationException(h3);
1953 +            rs[3].assertNotInvoked();
1954 +        }
1955 +
1956 +        checkCompletedNormally(f, v1);
1957 +        checkCancelled(g);
1958 +    }}
1959 +
1960      /**
1961       * applyToEither result completes exceptionally if action does
1962       */
# Line 1896 | Line 2009 | public class CompletableFutureTest exten
2009      {
2010          final CompletableFuture<Integer> f = new CompletableFuture<>();
2011          final CompletableFuture<Integer> g = new CompletableFuture<>();
2012 <        final IncAction[] rs = new IncAction[6];
2013 <        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
2012 >        final NoopConsumer[] rs = new NoopConsumer[6];
2013 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2014  
2015          final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2016          final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
# Line 1908 | Line 2021 | public class CompletableFutureTest exten
2021          f.complete(v1);
2022          checkCompletedNormally(h0, null);
2023          checkCompletedNormally(h1, null);
2024 <        rs[0].assertValue(inc(v1));
2025 <        rs[1].assertValue(inc(v1));
2024 >        rs[0].assertValue(v1);
2025 >        rs[1].assertValue(v1);
2026          final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2027          final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2028          checkCompletedNormally(h2, null);
2029          checkCompletedNormally(h3, null);
2030 <        rs[2].assertValue(inc(v1));
2031 <        rs[3].assertValue(inc(v1));
2030 >        rs[2].assertValue(v1);
2031 >        rs[3].assertValue(v1);
2032          g.complete(v2);
2033  
2034          // unspecified behavior - both source completions available
# Line 1923 | Line 2036 | public class CompletableFutureTest exten
2036          final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2037          checkCompletedNormally(h4, null);
2038          checkCompletedNormally(h5, null);
2039 <        assertTrue(Objects.equals(inc(v1), rs[4].value) ||
2040 <                   Objects.equals(inc(v2), rs[4].value));
2041 <        assertTrue(Objects.equals(inc(v1), rs[5].value) ||
2042 <                   Objects.equals(inc(v2), rs[5].value));
2039 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2040 >                   Objects.equals(v2, rs[4].value));
2041 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2042 >                   Objects.equals(v2, rs[5].value));
2043  
2044          checkCompletedNormally(f, v1);
2045          checkCompletedNormally(g, v2);
# Line 1934 | Line 2047 | public class CompletableFutureTest exten
2047          checkCompletedNormally(h1, null);
2048          checkCompletedNormally(h2, null);
2049          checkCompletedNormally(h3, null);
2050 <        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
2050 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2051      }}
2052  
2053      /**
# Line 1948 | Line 2061 | public class CompletableFutureTest exten
2061          final CompletableFuture<Integer> f = new CompletableFuture<>();
2062          final CompletableFuture<Integer> g = new CompletableFuture<>();
2063          final CFException ex = new CFException();
2064 <        final IncAction[] rs = new IncAction[6];
2065 <        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
2064 >        final NoopConsumer[] rs = new NoopConsumer[6];
2065 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2066  
2067          final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2068          final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
# Line 1972 | Line 2085 | public class CompletableFutureTest exten
2085          final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2086          try {
2087              assertNull(h4.join());
2088 <            rs[4].assertValue(inc(v1));
2088 >            rs[4].assertValue(v1);
2089          } catch (CompletionException ok) {
2090              checkCompletedWithWrappedCFException(h4, ex);
2091              rs[4].assertNotInvoked();
2092          }
2093          try {
2094              assertNull(h5.join());
2095 <            rs[5].assertValue(inc(v1));
2095 >            rs[5].assertValue(v1);
2096          } catch (CompletionException ok) {
2097              checkCompletedWithWrappedCFException(h5, ex);
2098              rs[5].assertNotInvoked();
# Line 1995 | Line 2108 | public class CompletableFutureTest exten
2108          for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2109      }}
2110  
2111 +    public void testAcceptEither_exceptionalCompletion2() {
2112 +        for (ExecutionMode m : ExecutionMode.values())
2113 +        for (boolean fFirst : new boolean[] { true, false })
2114 +        for (Integer v1 : new Integer[] { 1, null })
2115 +    {
2116 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
2117 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
2118 +        final CFException ex = new CFException();
2119 +        final NoopConsumer[] rs = new NoopConsumer[6];
2120 +        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2121 +
2122 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2123 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2124 +        if (fFirst) {
2125 +            f.complete(v1);
2126 +            g.completeExceptionally(ex);
2127 +        } else {
2128 +            g.completeExceptionally(ex);
2129 +            f.complete(v1);
2130 +        }
2131 +        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2132 +        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2133 +
2134 +        // unspecified behavior - both source completions available
2135 +        try {
2136 +            assertEquals(null, h0.join());
2137 +            rs[0].assertValue(v1);
2138 +        } catch (CompletionException ok) {
2139 +            checkCompletedWithWrappedCFException(h0, ex);
2140 +            rs[0].assertNotInvoked();
2141 +        }
2142 +        try {
2143 +            assertEquals(null, h1.join());
2144 +            rs[1].assertValue(v1);
2145 +        } catch (CompletionException ok) {
2146 +            checkCompletedWithWrappedCFException(h1, ex);
2147 +            rs[1].assertNotInvoked();
2148 +        }
2149 +        try {
2150 +            assertEquals(null, h2.join());
2151 +            rs[2].assertValue(v1);
2152 +        } catch (CompletionException ok) {
2153 +            checkCompletedWithWrappedCFException(h2, ex);
2154 +            rs[2].assertNotInvoked();
2155 +        }
2156 +        try {
2157 +            assertEquals(null, h3.join());
2158 +            rs[3].assertValue(v1);
2159 +        } catch (CompletionException ok) {
2160 +            checkCompletedWithWrappedCFException(h3, ex);
2161 +            rs[3].assertNotInvoked();
2162 +        }
2163 +
2164 +        checkCompletedNormally(f, v1);
2165 +        checkCompletedWithWrappedCFException(g, ex);
2166 +    }}
2167 +
2168      /**
2169       * acceptEither result completes exceptionally if either source cancelled
2170       */
# Line 2005 | Line 2175 | public class CompletableFutureTest exten
2175      {
2176          final CompletableFuture<Integer> f = new CompletableFuture<>();
2177          final CompletableFuture<Integer> g = new CompletableFuture<>();
2178 <        final IncAction[] rs = new IncAction[6];
2179 <        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
2178 >        final NoopConsumer[] rs = new NoopConsumer[6];
2179 >        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2180  
2181          final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2182          final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
# Line 2029 | Line 2199 | public class CompletableFutureTest exten
2199          final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2200          try {
2201              assertNull(h4.join());
2202 <            rs[4].assertValue(inc(v1));
2202 >            rs[4].assertValue(v1);
2203          } catch (CompletionException ok) {
2204              checkCompletedWithWrappedCancellationException(h4);
2205              rs[4].assertNotInvoked();
2206          }
2207          try {
2208              assertNull(h5.join());
2209 <            rs[5].assertValue(inc(v1));
2209 >            rs[5].assertValue(v1);
2210          } catch (CompletionException ok) {
2211              checkCompletedWithWrappedCancellationException(h5);
2212              rs[5].assertNotInvoked();
# Line 2096 | Line 2266 | public class CompletableFutureTest exten
2266       * runAfterEither result completes normally after normal completion
2267       * of either source
2268       */
2269 <    public void testRunAfterEither_normalCompletion1() {
2269 >    public void testRunAfterEither_normalCompletion() {
2270          for (ExecutionMode m : ExecutionMode.values())
2271          for (Integer v1 : new Integer[] { 1, null })
2272          for (Integer v2 : new Integer[] { 2, null })
2273      {
2274          final CompletableFuture<Integer> f = new CompletableFuture<>();
2275          final CompletableFuture<Integer> g = new CompletableFuture<>();
2276 <        final Noop r = new Noop(m);
2277 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2276 >        final Noop[] rs = new Noop[6];
2277 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2278  
2279 +        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2280 +        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2281 +        checkIncomplete(h0);
2282 +        checkIncomplete(h1);
2283 +        rs[0].assertNotInvoked();
2284 +        rs[1].assertNotInvoked();
2285          f.complete(v1);
2286 <        checkCompletedNormally(h, null);
2287 <        r.assertInvoked();
2288 <        g.complete(v2);
2289 <
2290 <        checkCompletedNormally(f, v1);
2291 <        checkCompletedNormally(g, v2);
2292 <        checkCompletedNormally(h, null);
2293 <        r.assertInvoked();
2294 <    }}
2295 <
2120 <    public void testRunAfterEither_normalCompletion2() {
2121 <        for (ExecutionMode m : ExecutionMode.values())
2122 <        for (Integer v1 : new Integer[] { 1, null })
2123 <        for (Integer v2 : new Integer[] { 2, null })
2124 <    {
2125 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2126 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2127 <        final Noop r = new Noop(m);
2128 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2286 >        checkCompletedNormally(h0, null);
2287 >        checkCompletedNormally(h1, null);
2288 >        rs[0].assertInvoked();
2289 >        rs[1].assertInvoked();
2290 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2291 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2292 >        checkCompletedNormally(h2, null);
2293 >        checkCompletedNormally(h3, null);
2294 >        rs[2].assertInvoked();
2295 >        rs[3].assertInvoked();
2296  
2297          g.complete(v2);
2131 –        checkCompletedNormally(h, null);
2132 –        r.assertInvoked();
2133 –        f.complete(v1);
2134 –
2135 –        checkCompletedNormally(f, v1);
2136 –        checkCompletedNormally(g, v2);
2137 –        checkCompletedNormally(h, null);
2138 –        r.assertInvoked();
2139 –        }}
2140 –
2141 –    public void testRunAfterEither_normalCompletion3() {
2142 –        for (ExecutionMode m : ExecutionMode.values())
2143 –        for (Integer v1 : new Integer[] { 1, null })
2144 –        for (Integer v2 : new Integer[] { 2, null })
2145 –    {
2146 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2147 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2148 –        final Noop r = new Noop(m);
2298  
2299 <        f.complete(v1);
2300 <        g.complete(v2);
2152 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2299 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2300 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2301  
2154 –        checkCompletedNormally(h, null);
2302          checkCompletedNormally(f, v1);
2303          checkCompletedNormally(g, v2);
2304 <        r.assertInvoked();
2304 >        checkCompletedNormally(h0, null);
2305 >        checkCompletedNormally(h1, null);
2306 >        checkCompletedNormally(h2, null);
2307 >        checkCompletedNormally(h3, null);
2308 >        checkCompletedNormally(h4, null);
2309 >        checkCompletedNormally(h5, null);
2310 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2311      }}
2312  
2313      /**
2314       * runAfterEither result completes exceptionally after exceptional
2315       * completion of either source
2316       */
2317 <    public void testRunAfterEither_exceptionalCompletion1() {
2317 >    public void testRunAfterEither_exceptionalCompletion() {
2318          for (ExecutionMode m : ExecutionMode.values())
2319          for (Integer v1 : new Integer[] { 1, null })
2320      {
2321          final CompletableFuture<Integer> f = new CompletableFuture<>();
2322          final CompletableFuture<Integer> g = new CompletableFuture<>();
2170 –        final Noop r = new Noop(m);
2171 –        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2323          final CFException ex = new CFException();
2324 +        final Noop[] rs = new Noop[6];
2325 +        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2326  
2327 +        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2328 +        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2329 +        checkIncomplete(h0);
2330 +        checkIncomplete(h1);
2331 +        rs[0].assertNotInvoked();
2332 +        rs[1].assertNotInvoked();
2333          f.completeExceptionally(ex);
2334 <        checkCompletedWithWrappedCFException(h, ex);
2335 <        g.complete(v1);
2336 <
2337 <        r.assertNotInvoked();
2338 <        checkCompletedNormally(g, v1);
2339 <        checkCompletedWithWrappedCFException(f, ex);
2181 <        checkCompletedWithWrappedCFException(h, ex);
2182 <    }}
2183 <
2184 <    public void testRunAfterEither_exceptionalCompletion2() {
2185 <        for (ExecutionMode m : ExecutionMode.values())
2186 <        for (Integer v1 : new Integer[] { 1, null })
2187 <    {
2188 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2189 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2190 <        final Noop r = new Noop(m);
2191 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2192 <        final CFException ex = new CFException();
2193 <
2194 <        g.completeExceptionally(ex);
2195 <        checkCompletedWithWrappedCFException(h, ex);
2196 <        f.complete(v1);
2197 <
2198 <        r.assertNotInvoked();
2199 <        checkCompletedNormally(f, v1);
2200 <        checkCompletedWithWrappedCFException(g, ex);
2201 <        checkCompletedWithWrappedCFException(h, ex);
2202 <    }}
2203 <
2204 <    public void testRunAfterEither_exceptionalCompletion3() {
2205 <        for (ExecutionMode m : ExecutionMode.values())
2206 <        for (Integer v1 : new Integer[] { 1, null })
2207 <    {
2208 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2209 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2210 <        final Noop r = new Noop(m);
2211 <        final CFException ex = new CFException();
2334 >        checkCompletedWithWrappedCFException(h0, ex);
2335 >        checkCompletedWithWrappedCFException(h1, ex);
2336 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2337 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2338 >        checkCompletedWithWrappedCFException(h2, ex);
2339 >        checkCompletedWithWrappedCFException(h3, ex);
2340  
2341 <        g.completeExceptionally(ex);
2214 <        f.complete(v1);
2215 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2341 >        g.complete(v1);
2342  
2343 <        // unspecified behavior
2344 <        Integer v;
2343 >        // unspecified behavior - both source completions available
2344 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2345 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2346          try {
2347 <            assertNull(h.join());
2348 <            r.assertInvoked();
2347 >            assertNull(h4.join());
2348 >            rs[4].assertInvoked();
2349          } catch (CompletionException ok) {
2350 <            checkCompletedWithWrappedCFException(h, ex);
2351 <            r.assertNotInvoked();
2350 >            checkCompletedWithWrappedCFException(h4, ex);
2351 >            rs[4].assertNotInvoked();
2352          }
2226 –
2227 –        checkCompletedWithWrappedCFException(g, ex);
2228 –        checkCompletedNormally(f, v1);
2229 –    }}
2230 –
2231 –    public void testRunAfterEither_exceptionalCompletion4() {
2232 –        for (ExecutionMode m : ExecutionMode.values())
2233 –        for (Integer v1 : new Integer[] { 1, null })
2234 –    {
2235 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2236 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2237 –        final Noop r = new Noop(m);
2238 –        final CFException ex = new CFException();
2239 –
2240 –        f.completeExceptionally(ex);
2241 –        g.complete(v1);
2242 –        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2243 –
2244 –        // unspecified behavior
2245 –        Integer v;
2353          try {
2354 <            assertNull(h.join());
2355 <            r.assertInvoked();
2354 >            assertNull(h5.join());
2355 >            rs[5].assertInvoked();
2356          } catch (CompletionException ok) {
2357 <            checkCompletedWithWrappedCFException(h, ex);
2358 <            r.assertNotInvoked();
2357 >            checkCompletedWithWrappedCFException(h5, ex);
2358 >            rs[5].assertNotInvoked();
2359          }
2360  
2361          checkCompletedWithWrappedCFException(f, ex);
2362          checkCompletedNormally(g, v1);
2363 <    }}
2364 <
2365 <    /**
2366 <     * runAfterEither result completes exceptionally if action does
2367 <     */
2368 <    public void testRunAfterEither_actionFailed1() {
2262 <        for (ExecutionMode m : ExecutionMode.values())
2263 <        for (Integer v1 : new Integer[] { 1, null })
2264 <        for (Integer v2 : new Integer[] { 2, null })
2265 <    {
2266 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2267 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2268 <        final FailingRunnable r = new FailingRunnable(m);
2269 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2270 <
2271 <        f.complete(v1);
2272 <        checkCompletedWithWrappedCFException(h);
2273 <        g.complete(v2);
2274 <        checkCompletedNormally(f, v1);
2275 <        checkCompletedNormally(g, v2);
2276 <    }}
2277 <
2278 <    public void testRunAfterEither_actionFailed2() {
2279 <        for (ExecutionMode m : ExecutionMode.values())
2280 <        for (Integer v1 : new Integer[] { 1, null })
2281 <        for (Integer v2 : new Integer[] { 2, null })
2282 <    {
2283 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2284 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2285 <        final FailingRunnable r = new FailingRunnable(m);
2286 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2287 <
2288 <        g.complete(v2);
2289 <        checkCompletedWithWrappedCFException(h);
2290 <        f.complete(v1);
2291 <        checkCompletedNormally(f, v1);
2292 <        checkCompletedNormally(g, v2);
2363 >        checkCompletedWithWrappedCFException(h0, ex);
2364 >        checkCompletedWithWrappedCFException(h1, ex);
2365 >        checkCompletedWithWrappedCFException(h2, ex);
2366 >        checkCompletedWithWrappedCFException(h3, ex);
2367 >        checkCompletedWithWrappedCFException(h4, ex);
2368 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2369      }}
2370  
2371      /**
2372       * runAfterEither result completes exceptionally if either source cancelled
2373       */
2374 <    public void testRunAfterEither_sourceCancelled1() {
2299 <        for (ExecutionMode m : ExecutionMode.values())
2300 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2301 <        for (Integer v1 : new Integer[] { 1, null })
2302 <    {
2303 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2304 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2305 <        final Noop r = new Noop(m);
2306 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2307 <
2308 <        assertTrue(f.cancel(mayInterruptIfRunning));
2309 <        checkCompletedWithWrappedCancellationException(h);
2310 <        g.complete(v1);
2311 <
2312 <        checkCancelled(f);
2313 <        r.assertNotInvoked();
2314 <        checkCompletedNormally(g, v1);
2315 <        checkCompletedWithWrappedCancellationException(h);
2316 <    }}
2317 <
2318 <    public void testRunAfterEither_sourceCancelled2() {
2374 >    public void testRunAfterEither_sourceCancelled() {
2375          for (ExecutionMode m : ExecutionMode.values())
2376          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2377          for (Integer v1 : new Integer[] { 1, null })
2378      {
2379          final CompletableFuture<Integer> f = new CompletableFuture<>();
2380          final CompletableFuture<Integer> g = new CompletableFuture<>();
2381 <        final Noop r = new Noop(m);
2382 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2327 <
2328 <        assertTrue(g.cancel(mayInterruptIfRunning));
2329 <        checkCompletedWithWrappedCancellationException(h);
2330 <        f.complete(v1);
2331 <
2332 <        checkCancelled(g);
2333 <        r.assertNotInvoked();
2334 <        checkCompletedNormally(f, v1);
2335 <        checkCompletedWithWrappedCancellationException(h);
2336 <    }}
2381 >        final Noop[] rs = new Noop[6];
2382 >        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2383  
2384 <    public void testRunAfterEither_sourceCancelled3() {
2385 <        for (ExecutionMode m : ExecutionMode.values())
2386 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2387 <        for (Integer v1 : new Integer[] { 1, null })
2388 <    {
2389 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2390 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2391 <        final Noop r = new Noop(m);
2384 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2385 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2386 >        checkIncomplete(h0);
2387 >        checkIncomplete(h1);
2388 >        rs[0].assertNotInvoked();
2389 >        rs[1].assertNotInvoked();
2390 >        f.cancel(mayInterruptIfRunning);
2391 >        checkCompletedWithWrappedCancellationException(h0);
2392 >        checkCompletedWithWrappedCancellationException(h1);
2393 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2394 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2395 >        checkCompletedWithWrappedCancellationException(h2);
2396 >        checkCompletedWithWrappedCancellationException(h3);
2397  
2398 <        assertTrue(g.cancel(mayInterruptIfRunning));
2348 <        f.complete(v1);
2349 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2398 >        g.complete(v1);
2399  
2400 <        // unspecified behavior
2401 <        Integer v;
2400 >        // unspecified behavior - both source completions available
2401 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2402 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2403          try {
2404 <            assertNull(h.join());
2405 <            r.assertInvoked();
2404 >            assertNull(h4.join());
2405 >            rs[4].assertInvoked();
2406          } catch (CompletionException ok) {
2407 <            checkCompletedWithWrappedCancellationException(h);
2408 <            r.assertNotInvoked();
2407 >            checkCompletedWithWrappedCancellationException(h4);
2408 >            rs[4].assertNotInvoked();
2409 >        }
2410 >        try {
2411 >            assertNull(h5.join());
2412 >            rs[5].assertInvoked();
2413 >        } catch (CompletionException ok) {
2414 >            checkCompletedWithWrappedCancellationException(h5);
2415 >            rs[5].assertNotInvoked();
2416          }
2417  
2418 <        checkCancelled(g);
2419 <        checkCompletedNormally(f, v1);
2418 >        checkCancelled(f);
2419 >        checkCompletedNormally(g, v1);
2420 >        checkCompletedWithWrappedCancellationException(h0);
2421 >        checkCompletedWithWrappedCancellationException(h1);
2422 >        checkCompletedWithWrappedCancellationException(h2);
2423 >        checkCompletedWithWrappedCancellationException(h3);
2424 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2425      }}
2426  
2427 <    public void testRunAfterEither_sourceCancelled4() {
2427 >    /**
2428 >     * runAfterEither result completes exceptionally if action does
2429 >     */
2430 >    public void testRunAfterEither_actionFailed() {
2431          for (ExecutionMode m : ExecutionMode.values())
2367 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2432          for (Integer v1 : new Integer[] { 1, null })
2433 +        for (Integer v2 : new Integer[] { 2, null })
2434      {
2435          final CompletableFuture<Integer> f = new CompletableFuture<>();
2436          final CompletableFuture<Integer> g = new CompletableFuture<>();
2437 <        final Noop r = new Noop(m);
2437 >        final FailingRunnable[] rs = new FailingRunnable[6];
2438 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2439  
2440 <        assertTrue(f.cancel(mayInterruptIfRunning));
2441 <        g.complete(v1);
2442 <        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2443 <
2444 <        // unspecified behavior
2445 <        Integer v;
2446 <        try {
2447 <            assertNull(h.join());
2448 <            r.assertInvoked();
2449 <        } catch (CompletionException ok) {
2450 <            checkCompletedWithWrappedCancellationException(h);
2451 <            r.assertNotInvoked();
2452 <        }
2440 >        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2441 >        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2442 >        f.complete(v1);
2443 >        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2444 >        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2445 >        checkCompletedWithWrappedCFException(h0);
2446 >        checkCompletedWithWrappedCFException(h1);
2447 >        checkCompletedWithWrappedCFException(h2);
2448 >        checkCompletedWithWrappedCFException(h3);
2449 >        for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2450 >        g.complete(v2);
2451 >        final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2452 >        final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2453 >        checkCompletedWithWrappedCFException(h4);
2454 >        checkCompletedWithWrappedCFException(h5);
2455  
2456 <        checkCancelled(f);
2457 <        checkCompletedNormally(g, v1);
2456 >        checkCompletedNormally(f, v1);
2457 >        checkCompletedNormally(g, v2);
2458 >        for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2459      }}
2460  
2461      /**

Diff Legend

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