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.67 by jsr166, Fri Jun 6 19:25:41 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 2095 | Line 2209 | public class CompletableFutureTest exten
2209		* runAfterEither result completes normally after normal completion
2210		* of either source
2211		*/
2212	<	public void testRunAfterEither_normalCompletion1() {
2212	>	public void testRunAfterEither_normalCompletion() {
2213		for (ExecutionMode m : ExecutionMode.values())
2214		for (Integer v1 : new Integer[] { 1, null })
2215		for (Integer v2 : new Integer[] { 2, null })
2216		{
2217		final CompletableFuture<Integer> f = new CompletableFuture<>();
2218		final CompletableFuture<Integer> g = new CompletableFuture<>();
2219	<	final Noop r = new Noop(m);
2220	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2219	>	final Noop[] rs = new Noop[6];
2220	>	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2221
2222	+	final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2223	+	final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2224	+	checkIncomplete(h0);
2225	+	checkIncomplete(h1);
2226	+	rs[0].assertNotInvoked();
2227	+	rs[1].assertNotInvoked();
2228		f.complete(v1);
2229	<	checkCompletedNormally(h, null);
2230	<	r.assertInvoked();
2231	<	g.complete(v2);
2232	<
2233	<	checkCompletedNormally(f, v1);
2234	<	checkCompletedNormally(g, v2);
2235	<	checkCompletedNormally(h, null);
2236	<	r.assertInvoked();
2237	<	}}
2238	<
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);
2229	>	checkCompletedNormally(h0, null);
2230	>	checkCompletedNormally(h1, null);
2231	>	rs[0].assertInvoked();
2232	>	rs[1].assertInvoked();
2233	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2234	>	final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2235	>	checkCompletedNormally(h2, null);
2236	>	checkCompletedNormally(h3, null);
2237	>	rs[2].assertInvoked();
2238	>	rs[3].assertInvoked();
2239
2240		g.complete(v2);
2130	–	checkCompletedNormally(h, null);
2131	–	r.assertInvoked();
2132	–	f.complete(v1);
2241
2242	<	checkCompletedNormally(f, v1);
2243	<	checkCompletedNormally(g, v2);
2136	<	checkCompletedNormally(h, null);
2137	<	r.assertInvoked();
2138	<	}}
2242	>	final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2243	>	final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2244
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);
2148	–
2149	–	f.complete(v1);
2150	–	g.complete(v2);
2151	–	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2152	–
2153	–	checkCompletedNormally(h, null);
2245		checkCompletedNormally(f, v1);
2246		checkCompletedNormally(g, v2);
2247	<	r.assertInvoked();
2247	>	checkCompletedNormally(h0, null);
2248	>	checkCompletedNormally(h1, null);
2249	>	checkCompletedNormally(h2, null);
2250	>	checkCompletedNormally(h3, null);
2251	>	checkCompletedNormally(h4, null);
2252	>	checkCompletedNormally(h5, null);
2253	>	for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2254		}}
2255
2256		/**
2257		* runAfterEither result completes exceptionally after exceptional
2258		* completion of either source
2259		*/
2260	<	public void testRunAfterEither_exceptionalCompletion1() {
2260	>	public void testRunAfterEither_exceptionalCompletion() {
2261		for (ExecutionMode m : ExecutionMode.values())
2262		for (Integer v1 : new Integer[] { 1, null })
2263		{
2264		final CompletableFuture<Integer> f = new CompletableFuture<>();
2265		final CompletableFuture<Integer> g = new CompletableFuture<>();
2169	–	final Noop r = new Noop(m);
2170	–	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2266		final CFException ex = new CFException();
2267	+	final Noop[] rs = new Noop[6];
2268	+	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2269
2270	+	final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2271	+	final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2272	+	checkIncomplete(h0);
2273	+	checkIncomplete(h1);
2274	+	rs[0].assertNotInvoked();
2275	+	rs[1].assertNotInvoked();
2276		f.completeExceptionally(ex);
2277	<	checkCompletedWithWrappedCFException(h, ex);
2278	<	g.complete(v1);
2279	<
2280	<	r.assertNotInvoked();
2281	<	checkCompletedNormally(g, v1);
2282	<	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();
2277	>	checkCompletedWithWrappedCFException(h0, ex);
2278	>	checkCompletedWithWrappedCFException(h1, ex);
2279	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2280	>	final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2281	>	checkCompletedWithWrappedCFException(h2, ex);
2282	>	checkCompletedWithWrappedCFException(h3, ex);
2283
2284	<	g.completeExceptionally(ex);
2213	<	f.complete(v1);
2214	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2284	>	g.complete(v1);
2285
2286	<	// unspecified behavior
2287	<	Integer v;
2286	>	// unspecified behavior - both source completions available
2287	>	final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2288	>	final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2289		try {
2290	<	assertNull(h.join());
2291	<	r.assertInvoked();
2290	>	assertNull(h4.join());
2291	>	rs[4].assertInvoked();
2292		} catch (CompletionException ok) {
2293	<	checkCompletedWithWrappedCFException(h, ex);
2294	<	r.assertNotInvoked();
2293	>	checkCompletedWithWrappedCFException(h4, ex);
2294	>	rs[4].assertNotInvoked();
2295		}
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;
2296		try {
2297	<	assertNull(h.join());
2298	<	r.assertInvoked();
2297	>	assertNull(h5.join());
2298	>	rs[5].assertInvoked();
2299		} catch (CompletionException ok) {
2300	<	checkCompletedWithWrappedCFException(h, ex);
2301	<	r.assertNotInvoked();
2300	>	checkCompletedWithWrappedCFException(h5, ex);
2301	>	rs[5].assertNotInvoked();
2302		}
2303
2304		checkCompletedWithWrappedCFException(f, ex);
2305		checkCompletedNormally(g, v1);
2306	<	}}
2307	<
2308	<	/**
2309	<	* runAfterEither result completes exceptionally if action does
2310	<	*/
2311	<	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);
2306	>	checkCompletedWithWrappedCFException(h0, ex);
2307	>	checkCompletedWithWrappedCFException(h1, ex);
2308	>	checkCompletedWithWrappedCFException(h2, ex);
2309	>	checkCompletedWithWrappedCFException(h3, ex);
2310	>	checkCompletedWithWrappedCFException(h4, ex);
2311	>	for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2312		}}
2313
2314		/**
2315		* runAfterEither result completes exceptionally if either source cancelled
2316		*/
2317	<	public void testRunAfterEither_sourceCancelled1() {
2317	>	public void testRunAfterEither_sourceCancelled() {
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);
2324	>	final Noop[] rs = new Noop[6];
2325	>	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2326
2327	<	assertTrue(f.cancel(mayInterruptIfRunning));
2328	<	checkCompletedWithWrappedCancellationException(h);
2329	<	g.complete(v1);
2330	<
2331	<	checkCancelled(f);
2332	<	r.assertNotInvoked();
2333	<	checkCompletedNormally(g, v1);
2334	<	checkCompletedWithWrappedCancellationException(h);
2335	<	}}
2336	<
2337	<	public void testRunAfterEither_sourceCancelled2() {
2338	<	for (ExecutionMode m : ExecutionMode.values())
2339	<	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);
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.cancel(mayInterruptIfRunning);
2334	>	checkCompletedWithWrappedCancellationException(h0);
2335	>	checkCompletedWithWrappedCancellationException(h1);
2336	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2337	>	final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2338	>	checkCompletedWithWrappedCancellationException(h2);
2339	>	checkCompletedWithWrappedCancellationException(h3);
2340
2341	<	assertTrue(g.cancel(mayInterruptIfRunning));
2347	<	f.complete(v1);
2348	<	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(h4.join());
2348	>	rs[4].assertInvoked();
2349	>	} catch (CompletionException ok) {
2350	>	checkCompletedWithWrappedCancellationException(h4);
2351	>	rs[4].assertNotInvoked();
2352	>	}
2353		try {
2354	<	assertNull(h.join());
2355	<	r.assertInvoked();
2354	>	assertNull(h5.join());
2355	>	rs[5].assertInvoked();
2356		} catch (CompletionException ok) {
2357	<	checkCompletedWithWrappedCancellationException(h);
2358	<	r.assertNotInvoked();
2357	>	checkCompletedWithWrappedCancellationException(h5);
2358	>	rs[5].assertNotInvoked();
2359		}
2360
2361	<	checkCancelled(g);
2362	<	checkCompletedNormally(f, v1);
2361	>	checkCancelled(f);
2362	>	checkCompletedNormally(g, v1);
2363	>	checkCompletedWithWrappedCancellationException(h0);
2364	>	checkCompletedWithWrappedCancellationException(h1);
2365	>	checkCompletedWithWrappedCancellationException(h2);
2366	>	checkCompletedWithWrappedCancellationException(h3);
2367	>	for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2368		}}
2369
2370	<	public void testRunAfterEither_sourceCancelled4() {
2370	>	/**
2371	>	* runAfterEither result completes exceptionally if action does
2372	>	*/
2373	>	public void testRunAfterEither_actionFailed() {
2374		for (ExecutionMode m : ExecutionMode.values())
2366	–	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2375		for (Integer v1 : new Integer[] { 1, null })
2376	+	for (Integer v2 : new Integer[] { 2, null })
2377		{
2378		final CompletableFuture<Integer> f = new CompletableFuture<>();
2379		final CompletableFuture<Integer> g = new CompletableFuture<>();
2380	<	final Noop r = new Noop(m);
2380	>	final FailingRunnable[] rs = new FailingRunnable[6];
2381	>	for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2382
2383	<	assertTrue(f.cancel(mayInterruptIfRunning));
2384	<	g.complete(v1);
2385	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2386	<
2387	<	// unspecified behavior
2388	<	Integer v;
2389	<	try {
2390	<	assertNull(h.join());
2391	<	r.assertInvoked();
2392	<	} catch (CompletionException ok) {
2393	<	checkCompletedWithWrappedCancellationException(h);
2394	<	r.assertNotInvoked();
2395	<	}
2383	>	final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
2384	>	final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
2385	>	f.complete(v1);
2386	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
2387	>	final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
2388	>	checkCompletedWithWrappedCFException(h0);
2389	>	checkCompletedWithWrappedCFException(h1);
2390	>	checkCompletedWithWrappedCFException(h2);
2391	>	checkCompletedWithWrappedCFException(h3);
2392	>	for (int i = 0; i < 4; i++) rs[i].assertInvoked();
2393	>	g.complete(v2);
2394	>	final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2395	>	final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2396	>	checkCompletedWithWrappedCFException(h4);
2397	>	checkCompletedWithWrappedCFException(h5);
2398
2399	<	checkCancelled(f);
2400	<	checkCompletedNormally(g, v1);
2399	>	checkCompletedNormally(f, v1);
2400	>	checkCompletedNormally(g, v2);
2401	>	for (int i = 0; i < 6; i++) rs[i].assertInvoked();
2402		}}
2403
2404		/**

Diff Legend

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