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.68 by jsr166, Fri Jun 6 19:35:54 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);
2335	<	g.complete(v1);
2336	<
2337	<	r.assertNotInvoked();
2338	<	checkCompletedNormally(g, v1);
2339	<	checkCompletedWithWrappedCFException(f, ex);
2180	<	checkCompletedWithWrappedCFException(h, ex);
2181	<	}}
2182	<
2183	<	public void testRunAfterEither_exceptionalCompletion2() {
2184	<	for (ExecutionMode m : ExecutionMode.values())
2185	<	for (Integer v1 : new Integer[] { 1, null })
2186	<	{
2187	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2188	<	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);
2210	<	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);
2213	<	f.complete(v1);
2214	<	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		}
2225	–
2226	–	checkCompletedWithWrappedCFException(g, ex);
2227	–	checkCompletedNormally(f, v1);
2228	–	}}
2229	–
2230	–	public void testRunAfterEither_exceptionalCompletion4() {
2231	–	for (ExecutionMode m : ExecutionMode.values())
2232	–	for (Integer v1 : new Integer[] { 1, null })
2233	–	{
2234	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2235	–	final CompletableFuture<Integer> g = new CompletableFuture<>();
2236	–	final Noop r = new Noop(m);
2237	–	final CFException ex = new CFException();
2238	–
2239	–	f.completeExceptionally(ex);
2240	–	g.complete(v1);
2241	–	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2242	–
2243	–	// unspecified behavior
2244	–	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() {
2261	<	for (ExecutionMode m : ExecutionMode.values())
2262	<	for (Integer v1 : new Integer[] { 1, null })
2263	<	for (Integer v2 : new Integer[] { 2, null })
2264	<	{
2265	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2266	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2267	<	final FailingRunnable r = new FailingRunnable(m);
2268	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2269	<
2270	<	f.complete(v1);
2271	<	checkCompletedWithWrappedCFException(h);
2272	<	g.complete(v2);
2273	<	checkCompletedNormally(f, v1);
2274	<	checkCompletedNormally(g, v2);
2275	<	}}
2276	<
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);
2286	<
2287	<	g.complete(v2);
2288	<	checkCompletedWithWrappedCFException(h);
2289	<	f.complete(v1);
2290	<	checkCompletedNormally(f, v1);
2291	<	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() {
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);
2381	>	final Noop[] rs = new Noop[6];
2382	>	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2383
2384	<	assertTrue(f.cancel(mayInterruptIfRunning));
2385	<	checkCompletedWithWrappedCancellationException(h);
2386	<	g.complete(v1);
2387	<
2388	<	checkCancelled(f);
2389	<	r.assertNotInvoked();
2390	<	checkCompletedNormally(g, v1);
2391	<	checkCompletedWithWrappedCancellationException(h);
2392	<	}}
2393	<
2394	<	public void testRunAfterEither_sourceCancelled2() {
2395	<	for (ExecutionMode m : ExecutionMode.values())
2396	<	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);
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));
2347	<	f.complete(v1);
2348	<	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(h4.join());
2405	>	rs[4].assertInvoked();
2406	>	} catch (CompletionException ok) {
2407	>	checkCompletedWithWrappedCancellationException(h4);
2408	>	rs[4].assertNotInvoked();
2409	>	}
2410		try {
2411	<	assertNull(h.join());
2412	<	r.assertInvoked();
2411	>	assertNull(h5.join());
2412	>	rs[5].assertInvoked();
2413		} catch (CompletionException ok) {
2414	<	checkCompletedWithWrappedCancellationException(h);
2415	<	r.assertNotInvoked();
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())
2366	–	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