ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/CompletableFutureTest.java

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.64 by jsr166, Fri Jun 6 17:08:48 2014 UTC vs.
Revision 1.69 by jsr166, Fri Jun 6 19:39:50 2014 UTC

#	Line 1765 | 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 1788 | 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 1821 | 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 1843 | 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 1994 | 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 2095 | 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	<
2119	<	public void testRunAfterEither_normalCompletion2() {
2120	<	for (ExecutionMode m : ExecutionMode.values())
2121	<	for (Integer v1 : new Integer[] { 1, null })
2122	<	for (Integer v2 : new Integer[] { 2, null })
2123	<	{
2124	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2125	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2126	<	final Noop r = new Noop(m);
2127	<	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);
2130	–	checkCompletedNormally(h, null);
2131	–	r.assertInvoked();
2132	–	f.complete(v1);
2133	–
2134	–	checkCompletedNormally(f, v1);
2135	–	checkCompletedNormally(g, v2);
2136	–	checkCompletedNormally(h, null);
2137	–	r.assertInvoked();
2138	–	}}
2139	–
2140	–	public void testRunAfterEither_normalCompletion3() {
2141	–	for (ExecutionMode m : ExecutionMode.values())
2142	–	for (Integer v1 : new Integer[] { 1, null })
2143	–	for (Integer v2 : new Integer[] { 2, null })
2144	–	{
2145	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2146	–	final CompletableFuture<Integer> g = new CompletableFuture<>();
2147	–	final Noop r = new Noop(m);
2298
2299	<	f.complete(v1);
2300	<	g.complete(v2);
2151	<	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
2153	–	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<>();
2169	–	final Noop r = new Noop(m);
2170	–	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);
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.complete(v1);
2342
2343	<	r.assertNotInvoked();
2344	<	checkCompletedNormally(g, v1);
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(h4.join());
2348	>	rs[4].assertInvoked();
2349	>	} catch (CompletionException ok) {
2350	>	checkCompletedWithWrappedCFException(h4, ex);
2351	>	rs[4].assertNotInvoked();
2352	>	}
2353	>	try {
2354	>	assertNull(h5.join());
2355	>	rs[5].assertInvoked();
2356	>	} catch (CompletionException ok) {
2357	>	checkCompletedWithWrappedCFException(h5, ex);
2358	>	rs[5].assertNotInvoked();
2359	>	}
2360	>
2361		checkCompletedWithWrappedCFException(f, ex);
2362	<	checkCompletedWithWrappedCFException(h, ex);
2362	>	checkCompletedNormally(g, v1);
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		public void testRunAfterEither_exceptionalCompletion2() {
2372		for (ExecutionMode m : ExecutionMode.values())
2373	+	for (boolean fFirst : new boolean[] { true, false })
2374		for (Integer v1 : new Integer[] { 1, null })
2375		{
2376		final CompletableFuture<Integer> f = new CompletableFuture<>();
2377		final CompletableFuture<Integer> g = new CompletableFuture<>();
2189	–	final Noop r = new Noop(m);
2190	–	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2191	–	final CFException ex = new CFException();
2192	–
2193	–	g.completeExceptionally(ex);
2194	–	checkCompletedWithWrappedCFException(h, ex);
2195	–	f.complete(v1);
2196	–
2197	–	r.assertNotInvoked();
2198	–	checkCompletedNormally(f, v1);
2199	–	checkCompletedWithWrappedCFException(g, ex);
2200	–	checkCompletedWithWrappedCFException(h, ex);
2201	–	}}
2202	–
2203	–	public void testRunAfterEither_exceptionalCompletion3() {
2204	–	for (ExecutionMode m : ExecutionMode.values())
2205	–	for (Integer v1 : new Integer[] { 1, null })
2206	–	{
2207	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2208	–	final CompletableFuture<Integer> g = new CompletableFuture<>();
2209	–	final Noop r = new Noop(m);
2378		final CFException ex = new CFException();
2379	+	final Noop[] rs = new Noop[6];
2380	+	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2381
2382	<	g.completeExceptionally(ex);
2383	<	f.complete(v1);
2384	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2382	>	final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2383	>	final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2384	>	if (fFirst) {
2385	>	f.complete(v1);
2386	>	g.completeExceptionally(ex);
2387	>	} else {
2388	>	g.completeExceptionally(ex);
2389	>	f.complete(v1);
2390	>	}
2391	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2392	>	final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2393
2394	<	// unspecified behavior
2395	<	Integer v;
2394	>	// unspecified behavior - both source completions available
2395	>	try {
2396	>	assertEquals(null, h0.join());
2397	>	rs[0].assertInvoked();
2398	>	} catch (CompletionException ok) {
2399	>	checkCompletedWithWrappedCFException(h0, ex);
2400	>	rs[0].assertNotInvoked();
2401	>	}
2402	>	try {
2403	>	assertEquals(null, h1.join());
2404	>	rs[1].assertInvoked();
2405	>	} catch (CompletionException ok) {
2406	>	checkCompletedWithWrappedCFException(h1, ex);
2407	>	rs[1].assertNotInvoked();
2408	>	}
2409	>	try {
2410	>	assertEquals(null, h2.join());
2411	>	rs[2].assertInvoked();
2412	>	} catch (CompletionException ok) {
2413	>	checkCompletedWithWrappedCFException(h2, ex);
2414	>	rs[2].assertNotInvoked();
2415	>	}
2416		try {
2417	<	assertNull(h.join());
2418	<	r.assertInvoked();
2417	>	assertEquals(null, h3.join());
2418	>	rs[3].assertInvoked();
2419		} catch (CompletionException ok) {
2420	<	checkCompletedWithWrappedCFException(h, ex);
2421	<	r.assertNotInvoked();
2420	>	checkCompletedWithWrappedCFException(h3, ex);
2421	>	rs[3].assertNotInvoked();
2422		}
2423
2226	–	checkCompletedWithWrappedCFException(g, ex);
2424		checkCompletedNormally(f, v1);
2425	+	checkCompletedWithWrappedCFException(g, ex);
2426		}}
2427
2428	<	public void testRunAfterEither_exceptionalCompletion4() {
2428	>	/**
2429	>	* runAfterEither result completes exceptionally if either source cancelled
2430	>	*/
2431	>	public void testRunAfterEither_sourceCancelled() {
2432		for (ExecutionMode m : ExecutionMode.values())
2433	+	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2434		for (Integer v1 : new Integer[] { 1, null })
2435		{
2436		final CompletableFuture<Integer> f = new CompletableFuture<>();
2437		final CompletableFuture<Integer> g = new CompletableFuture<>();
2438	<	final Noop r = new Noop(m);
2439	<	final CFException ex = new CFException();
2438	>	final Noop[] rs = new Noop[6];
2439	>	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2440	>
2441	>	final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2442	>	final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2443	>	checkIncomplete(h0);
2444	>	checkIncomplete(h1);
2445	>	rs[0].assertNotInvoked();
2446	>	rs[1].assertNotInvoked();
2447	>	f.cancel(mayInterruptIfRunning);
2448	>	checkCompletedWithWrappedCancellationException(h0);
2449	>	checkCompletedWithWrappedCancellationException(h1);
2450	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2451	>	final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2452	>	checkCompletedWithWrappedCancellationException(h2);
2453	>	checkCompletedWithWrappedCancellationException(h3);
2454
2239	–	f.completeExceptionally(ex);
2455		g.complete(v1);
2241	–	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2456
2457	<	// unspecified behavior
2458	<	Integer v;
2457	>	// unspecified behavior - both source completions available
2458	>	final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2459	>	final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2460		try {
2461	<	assertNull(h.join());
2462	<	r.assertInvoked();
2461	>	assertNull(h4.join());
2462	>	rs[4].assertInvoked();
2463	>	} catch (CompletionException ok) {
2464	>	checkCompletedWithWrappedCancellationException(h4);
2465	>	rs[4].assertNotInvoked();
2466	>	}
2467	>	try {
2468	>	assertNull(h5.join());
2469	>	rs[5].assertInvoked();
2470		} catch (CompletionException ok) {
2471	<	checkCompletedWithWrappedCFException(h, ex);
2472	<	r.assertNotInvoked();
2471	>	checkCompletedWithWrappedCancellationException(h5);
2472	>	rs[5].assertNotInvoked();
2473		}
2474
2475	<	checkCompletedWithWrappedCFException(f, ex);
2475	>	checkCancelled(f);
2476		checkCompletedNormally(g, v1);
2477	+	checkCompletedWithWrappedCancellationException(h0);
2478	+	checkCompletedWithWrappedCancellationException(h1);
2479	+	checkCompletedWithWrappedCancellationException(h2);
2480	+	checkCompletedWithWrappedCancellationException(h3);
2481	+	for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2482		}}
2483
2484		/**
2485		* runAfterEither result completes exceptionally if action does
2486		*/
2487	<	public void testRunAfterEither_actionFailed1() {
2487	>	public void testRunAfterEither_actionFailed() {
2488		for (ExecutionMode m : ExecutionMode.values())
2489		for (Integer v1 : new Integer[] { 1, null })
2490		for (Integer v2 : new Integer[] { 2, null })
2491		{
2492		final CompletableFuture<Integer> f = new CompletableFuture<>();
2493		final CompletableFuture<Integer> g = new CompletableFuture<>();
2494	<	final FailingRunnable r = new FailingRunnable(m);
2495	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2494	>	final FailingRunnable[] rs = new FailingRunnable[6];
2495	>	for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2496
2497	+	final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2498	+	final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2499		f.complete(v1);
2500	<	checkCompletedWithWrappedCFException(h);
2500	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2501	>	final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2502	>	checkCompletedWithWrappedCFException(h0);
2503	>	checkCompletedWithWrappedCFException(h1);
2504	>	checkCompletedWithWrappedCFException(h2);
2505	>	checkCompletedWithWrappedCFException(h3);
2506	>	for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2507		g.complete(v2);
2508	<	checkCompletedNormally(f, v1);
2509	<	checkCompletedNormally(g, v2);
2510	<	}}
2511	<
2277	<	public void testRunAfterEither_actionFailed2() {
2278	<	for (ExecutionMode m : ExecutionMode.values())
2279	<	for (Integer v1 : new Integer[] { 1, null })
2280	<	for (Integer v2 : new Integer[] { 2, null })
2281	<	{
2282	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2283	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2284	<	final FailingRunnable r = new FailingRunnable(m);
2285	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2508	>	final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2509	>	final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2510	>	checkCompletedWithWrappedCFException(h4);
2511	>	checkCompletedWithWrappedCFException(h5);
2512
2287	–	g.complete(v2);
2288	–	checkCompletedWithWrappedCFException(h);
2289	–	f.complete(v1);
2513		checkCompletedNormally(f, v1);
2514		checkCompletedNormally(g, v2);
2515	<	}}
2293	<
2294	<	/**
2295	<	* runAfterEither result completes exceptionally if either source cancelled
2296	<	*/
2297	<	public void testRunAfterEither_sourceCancelled1() {
2298	<	for (ExecutionMode m : ExecutionMode.values())
2299	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2300	<	for (Integer v1 : new Integer[] { 1, null })
2301	<	{
2302	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2303	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2304	<	final Noop r = new Noop(m);
2305	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2306	<
2307	<	assertTrue(f.cancel(mayInterruptIfRunning));
2308	<	checkCompletedWithWrappedCancellationException(h);
2309	<	g.complete(v1);
2310	<
2311	<	checkCancelled(f);
2312	<	r.assertNotInvoked();
2313	<	checkCompletedNormally(g, v1);
2314	<	checkCompletedWithWrappedCancellationException(h);
2315	<	}}
2316	<
2317	<	public void testRunAfterEither_sourceCancelled2() {
2318	<	for (ExecutionMode m : ExecutionMode.values())
2319	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2320	<	for (Integer v1 : new Integer[] { 1, null })
2321	<	{
2322	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2323	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2324	<	final Noop r = new Noop(m);
2325	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2326	<
2327	<	assertTrue(g.cancel(mayInterruptIfRunning));
2328	<	checkCompletedWithWrappedCancellationException(h);
2329	<	f.complete(v1);
2330	<
2331	<	checkCancelled(g);
2332	<	r.assertNotInvoked();
2333	<	checkCompletedNormally(f, v1);
2334	<	checkCompletedWithWrappedCancellationException(h);
2335	<	}}
2336	<
2337	<	public void testRunAfterEither_sourceCancelled3() {
2338	<	for (ExecutionMode m : ExecutionMode.values())
2339	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2340	<	for (Integer v1 : new Integer[] { 1, null })
2341	<	{
2342	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2343	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2344	<	final Noop r = new Noop(m);
2345	<
2346	<	assertTrue(g.cancel(mayInterruptIfRunning));
2347	<	f.complete(v1);
2348	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2349	<
2350	<	// unspecified behavior
2351	<	Integer v;
2352	<	try {
2353	<	assertNull(h.join());
2354	<	r.assertInvoked();
2355	<	} catch (CompletionException ok) {
2356	<	checkCompletedWithWrappedCancellationException(h);
2357	<	r.assertNotInvoked();
2358	<	}
2359	<
2360	<	checkCancelled(g);
2361	<	checkCompletedNormally(f, v1);
2362	<	}}
2363	<
2364	<	public void testRunAfterEither_sourceCancelled4() {
2365	<	for (ExecutionMode m : ExecutionMode.values())
2366	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2367	<	for (Integer v1 : new Integer[] { 1, null })
2368	<	{
2369	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2370	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2371	<	final Noop r = new Noop(m);
2372	<
2373	<	assertTrue(f.cancel(mayInterruptIfRunning));
2374	<	g.complete(v1);
2375	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2376	<
2377	<	// unspecified behavior
2378	<	Integer v;
2379	<	try {
2380	<	assertNull(h.join());
2381	<	r.assertInvoked();
2382	<	} catch (CompletionException ok) {
2383	<	checkCompletedWithWrappedCancellationException(h);
2384	<	r.assertNotInvoked();
2385	<	}
2386	<
2387	<	checkCancelled(f);
2388	<	checkCompletedNormally(g, v1);
2515	>	for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2516		}}
2517
2518		/**

Diff Legend

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