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.62 by jsr166, Fri Jun 6 01:19:22 2014 UTC vs.
Revision 1.67 by jsr166, Fri Jun 6 19:25:41 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 415 | Line 415 | public class CompletableFutureTest exten
415		}
416		}
417
418	<	class FailingSupplier extends CheckedAction implements Supplier<Integer>
418	>	class FailingSupplier extends CheckedAction
419	>	implements Supplier<Integer>
420		{
421		FailingSupplier(ExecutionMode m) { super(m); }
422		public Integer get() {
#	Line 424 | Line 425 | public class CompletableFutureTest exten
425		}
426		}
427
428	<	class FailingConsumer extends CheckedAction implements Consumer<Integer> {
428	>	class FailingConsumer extends CheckedIntegerAction
429	>	implements Consumer<Integer>
430	>	{
431		FailingConsumer(ExecutionMode m) { super(m); }
432		public void accept(Integer x) {
433		invoked();
434	+	value = x;
435		throw new CFException();
436		}
437		}
438
439	<	class FailingBiConsumer extends CheckedAction
439	>	class FailingBiConsumer extends CheckedIntegerAction
440		implements BiConsumer<Integer, Integer>
441		{
442		FailingBiConsumer(ExecutionMode m) { super(m); }
443		public void accept(Integer x, Integer y) {
444		invoked();
445	+	value = subtract(x, y);
446		throw new CFException();
447		}
448		}
449
450	<	class FailingFunction extends CheckedAction
450	>	class FailingFunction extends CheckedIntegerAction
451		implements Function<Integer, Integer>
452		{
453		FailingFunction(ExecutionMode m) { super(m); }
454		public Integer apply(Integer x) {
455		invoked();
456	+	value = x;
457		throw new CFException();
458		}
459		}
460
461	<	class FailingBiFunction extends CheckedAction
461	>	class FailingBiFunction extends CheckedIntegerAction
462		implements BiFunction<Integer, Integer, Integer>
463		{
464		FailingBiFunction(ExecutionMode m) { super(m); }
465		public Integer apply(Integer x, Integer y) {
466		invoked();
467	+	value = subtract(x, y);
468		throw new CFException();
469		}
470		}
#	Line 471 | Line 478 | public class CompletableFutureTest exten
478		}
479
480
481	<	class CompletableFutureInc extends CheckedAction
481	>	class CompletableFutureInc extends CheckedIntegerAction
482		implements Function<Integer, CompletableFuture<Integer>>
483		{
484		CompletableFutureInc(ExecutionMode m) { super(m); }
485		public CompletableFuture<Integer> apply(Integer x) {
486		invoked();
487	+	value = x;
488		CompletableFuture<Integer> f = new CompletableFuture<>();
489		f.complete(inc(x));
490		return f;
491		}
492		}
493
494	<	class FailingCompletableFutureFunction extends CheckedAction
494	>	class FailingCompletableFutureFunction extends CheckedIntegerAction
495		implements Function<Integer, CompletableFuture<Integer>>
496		{
497		FailingCompletableFutureFunction(ExecutionMode m) { super(m); }
498		public CompletableFuture<Integer> apply(Integer x) {
499		invoked();
500	+	value = x;
501		throw new CFException();
502		}
503		}
#	Line 1240 | 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 1249 | Line 1258 | public class CompletableFutureTest exten
1258		}
1259
1260		checkCompletedNormally(g, null);
1261	+	r.assertValue(v1);
1262		checkCompletedNormally(f, v1);
1253	–	r.assertInvoked();
1254	–	r.assertValue(inc(v1));
1263		}}
1264
1265		/**
#	Line 1264 | 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 1286 | 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 1757 | 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 1780 | 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 1813 | 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 1835 | Line 1900 | public class CompletableFutureTest exten
1900		for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1901		}}
1902
1903	<	/**
1839	<	* applyToEither result completes exceptionally if action does
1840	<	*/
1841	<	public void testApplyToEither_actionFailed() {
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 })
1844	–	for (Integer v2 : new Integer[] { 2, null })
1908		{
1909		final CompletableFuture<Integer> f = new CompletableFuture<>();
1910		final CompletableFuture<Integer> g = new CompletableFuture<>();
1911	<	final FailingFunction[] rs = new FailingFunction[6];
1912	<	for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
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	<	f.complete(v1);
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	<	g.complete(v2);
1926	<	final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1927	<	final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1928	<
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	<	checkCompletedNormally(g, v2);
1862	<	checkCompletedWithWrappedCFException(h0);
1863	<	checkCompletedWithWrappedCFException(h1);
1864	<	checkCompletedWithWrappedCFException(h2);
1865	<	checkCompletedWithWrappedCFException(h3);
1866	<	checkCompletedWithWrappedCFException(h4);
1867	<	checkCompletedWithWrappedCFException(h5);
1868	<	for (int i = 0; i < rs.length; i++) rs[i].assertInvoked();
1957	>	checkCancelled(g);
1958		}}
1959
1960		/**
1961	<	* acceptEither result completes normally after normal completion
1873	<	* of either source
1961	>	* applyToEither result completes exceptionally if action does
1962		*/
1963	<	public void testAcceptEither_normalCompletion1() {
1963	>	public void testApplyToEither_actionFailed() {
1964		for (ExecutionMode m : ExecutionMode.values())
1965		for (Integer v1 : new Integer[] { 1, null })
1966		for (Integer v2 : new Integer[] { 2, null })
1967		{
1968		final CompletableFuture<Integer> f = new CompletableFuture<>();
1969		final CompletableFuture<Integer> g = new CompletableFuture<>();
1970	<	final IncAction r = new IncAction(m);
1971	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1970	>	final FailingFunction[] rs = new FailingFunction[6];
1971	>	for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1972
1973	+	final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1974	+	final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1975		f.complete(v1);
1976	<	checkCompletedNormally(h, null);
1977	<	assertEquals(inc(v1), r.value);
1978	<	g.complete(v2);
1976	>	final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1977	>	final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1978	>	checkCompletedWithWrappedCFException(h0);
1979	>	checkCompletedWithWrappedCFException(h1);
1980	>	checkCompletedWithWrappedCFException(h2);
1981	>	checkCompletedWithWrappedCFException(h3);
1982	>	for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
1983
1984	<	checkCompletedNormally(f, v1);
1891	<	checkCompletedNormally(g, v2);
1892	<	checkCompletedNormally(h, null);
1893	<	}}
1984	>	g.complete(v2);
1985
1986	<	public void testAcceptEither_normalCompletion2() {
1987	<	for (ExecutionMode m : ExecutionMode.values())
1988	<	for (Integer v1 : new Integer[] { 1, null })
1898	<	for (Integer v2 : new Integer[] { 2, null })
1899	<	{
1900	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
1901	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
1902	<	final IncAction r = new IncAction(m);
1903	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1986	>	// unspecified behavior - both source completions available
1987	>	final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1988	>	final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1989
1990	<	g.complete(v2);
1991	<	checkCompletedNormally(h, null);
1992	<	assertEquals(inc(v2), r.value);
1993	<	f.complete(v1);
1990	>	checkCompletedWithWrappedCFException(h4);
1991	>	assertTrue(Objects.equals(v1, rs[4].value) ||
1992	>	Objects.equals(v2, rs[4].value));
1993	>	checkCompletedWithWrappedCFException(h5);
1994	>	assertTrue(Objects.equals(v1, rs[5].value) ||
1995	>	Objects.equals(v2, rs[5].value));
1996
1997		checkCompletedNormally(f, v1);
1998		checkCompletedNormally(g, v2);
1912	–	checkCompletedNormally(h, null);
1999		}}
2000
2001	<	public void testAcceptEither_normalCompletion3() {
2001	>	/**
2002	>	* acceptEither result completes normally after normal completion
2003	>	* of either source
2004	>	*/
2005	>	public void testAcceptEither_normalCompletion() {
2006		for (ExecutionMode m : ExecutionMode.values())
2007		for (Integer v1 : new Integer[] { 1, null })
2008		for (Integer v2 : new Integer[] { 2, null })
2009		{
2010		final CompletableFuture<Integer> f = new CompletableFuture<>();
2011		final CompletableFuture<Integer> g = new CompletableFuture<>();
2012	<	final IncAction r = 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]);
2017	+	checkIncomplete(h0);
2018	+	checkIncomplete(h1);
2019	+	rs[0].assertNotInvoked();
2020	+	rs[1].assertNotInvoked();
2021		f.complete(v1);
2022	+	checkCompletedNormally(h0, null);
2023	+	checkCompletedNormally(h1, null);
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(v1);
2031	+	rs[3].assertValue(v1);
2032		g.complete(v2);
1926	–	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2033
2034	<	checkCompletedNormally(h, null);
2034	>	// unspecified behavior - both source completions available
2035	>	final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2036	>	final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2037	>	checkCompletedNormally(h4, null);
2038	>	checkCompletedNormally(h5, null);
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);
2046	<
2047	<	// unspecified behavior
2048	<	assertTrue(Objects.equals(r.value, inc(v1)) ||
2049	<	Objects.equals(r.value, inc(v2)));
2046	>	checkCompletedNormally(h0, null);
2047	>	checkCompletedNormally(h1, null);
2048	>	checkCompletedNormally(h2, null);
2049	>	checkCompletedNormally(h3, null);
2050	>	for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2051		}}
2052
2053		/**
2054		* acceptEither result completes exceptionally after exceptional
2055		* completion of either source
2056		*/
2057	<	public void testAcceptEither_exceptionalCompletion1() {
2057	>	public void testAcceptEither_exceptionalCompletion() {
2058		for (ExecutionMode m : ExecutionMode.values())
2059		for (Integer v1 : new Integer[] { 1, null })
2060		{
2061		final CompletableFuture<Integer> f = new CompletableFuture<>();
2062		final CompletableFuture<Integer> g = new CompletableFuture<>();
1947	–	final IncAction r = new IncAction(m);
1948	–	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2063		final CFException ex = new CFException();
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]);
2069	+	checkIncomplete(h0);
2070	+	checkIncomplete(h1);
2071	+	rs[0].assertNotInvoked();
2072	+	rs[1].assertNotInvoked();
2073		f.completeExceptionally(ex);
2074	<	checkCompletedWithWrappedCFException(h, ex);
2075	<	g.complete(v1);
2076	<
2077	<	r.assertNotInvoked();
2078	<	checkCompletedNormally(g, v1);
2079	<	checkCompletedWithWrappedCFException(f, ex);
1958	<	checkCompletedWithWrappedCFException(h, ex);
1959	<	}}
1960	<
1961	<	public void testAcceptEither_exceptionalCompletion2() {
1962	<	for (ExecutionMode m : ExecutionMode.values())
1963	<	for (Integer v1 : new Integer[] { 1, null })
1964	<	{
1965	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
1966	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
1967	<	final IncAction r = new IncAction(m);
1968	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1969	<	final CFException ex = new CFException();
1970	<
1971	<	g.completeExceptionally(ex);
1972	<	checkCompletedWithWrappedCFException(h, ex);
1973	<	f.complete(v1);
1974	<
1975	<	r.assertNotInvoked();
1976	<	checkCompletedNormally(f, v1);
1977	<	checkCompletedWithWrappedCFException(g, ex);
1978	<	checkCompletedWithWrappedCFException(h, ex);
1979	<	}}
1980	<
1981	<	public void testAcceptEither_exceptionalCompletion3() {
1982	<	for (ExecutionMode m : ExecutionMode.values())
1983	<	for (Integer v1 : new Integer[] { 1, null })
1984	<	{
1985	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
1986	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
1987	<	final IncAction r = new IncAction(m);
1988	<	final CFException ex = new CFException();
2074	>	checkCompletedWithWrappedCFException(h0, ex);
2075	>	checkCompletedWithWrappedCFException(h1, ex);
2076	>	final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2077	>	final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2078	>	checkCompletedWithWrappedCFException(h2, ex);
2079	>	checkCompletedWithWrappedCFException(h3, ex);
2080
2081	<	g.completeExceptionally(ex);
1991	<	f.complete(v1);
1992	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2081	>	g.complete(v1);
2082
2083	<	// unspecified behavior
2084	<	Integer v;
2083	>	// unspecified behavior - both source completions available
2084	>	final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2085	>	final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2086		try {
2087	<	assertNull(h.join());
2088	<	r.assertInvoked();
1999	<	assertEquals(inc(v1), r.value);
2087	>	assertNull(h4.join());
2088	>	rs[4].assertValue(v1);
2089		} catch (CompletionException ok) {
2090	<	checkCompletedWithWrappedCFException(h, ex);
2091	<	r.assertNotInvoked();
2090	>	checkCompletedWithWrappedCFException(h4, ex);
2091	>	rs[4].assertNotInvoked();
2092		}
2004	–
2005	–	checkCompletedWithWrappedCFException(g, ex);
2006	–	checkCompletedNormally(f, v1);
2007	–	}}
2008	–
2009	–	public void testAcceptEither_exceptionalCompletion4() {
2010	–	for (ExecutionMode m : ExecutionMode.values())
2011	–	for (Integer v1 : new Integer[] { 1, null })
2012	–	{
2013	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2014	–	final CompletableFuture<Integer> g = new CompletableFuture<>();
2015	–	final IncAction r = new IncAction(m);
2016	–	final CFException ex = new CFException();
2017	–
2018	–	f.completeExceptionally(ex);
2019	–	g.complete(v1);
2020	–	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2021	–
2022	–	// unspecified behavior
2023	–	Integer v;
2093		try {
2094	<	assertNull(h.join());
2095	<	r.assertInvoked();
2027	<	assertEquals(inc(v1), r.value);
2094	>	assertNull(h5.join());
2095	>	rs[5].assertValue(v1);
2096		} catch (CompletionException ok) {
2097	<	checkCompletedWithWrappedCFException(h, ex);
2098	<	r.assertNotInvoked();
2097	>	checkCompletedWithWrappedCFException(h5, ex);
2098	>	rs[5].assertNotInvoked();
2099		}
2100
2101		checkCompletedWithWrappedCFException(f, ex);
2102		checkCompletedNormally(g, v1);
2103	<	}}
2104	<
2105	<	/**
2106	<	* acceptEither result completes exceptionally if action does
2107	<	*/
2108	<	public void testAcceptEither_actionFailed1() {
2041	<	for (ExecutionMode m : ExecutionMode.values())
2042	<	for (Integer v1 : new Integer[] { 1, null })
2043	<	for (Integer v2 : new Integer[] { 2, null })
2044	<	{
2045	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2046	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2047	<	final FailingConsumer r = new FailingConsumer(m);
2048	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2049	<
2050	<	f.complete(v1);
2051	<	checkCompletedWithWrappedCFException(h);
2052	<	g.complete(v2);
2053	<	checkCompletedNormally(f, v1);
2054	<	checkCompletedNormally(g, v2);
2055	<	}}
2056	<
2057	<	public void testAcceptEither_actionFailed2() {
2058	<	for (ExecutionMode m : ExecutionMode.values())
2059	<	for (Integer v1 : new Integer[] { 1, null })
2060	<	for (Integer v2 : new Integer[] { 2, null })
2061	<	{
2062	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2063	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2064	<	final FailingConsumer r = new FailingConsumer(m);
2065	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2066	<
2067	<	g.complete(v2);
2068	<	checkCompletedWithWrappedCFException(h);
2069	<	f.complete(v1);
2070	<	checkCompletedNormally(f, v1);
2071	<	checkCompletedNormally(g, v2);
2103	>	checkCompletedWithWrappedCFException(h0, ex);
2104	>	checkCompletedWithWrappedCFException(h1, ex);
2105	>	checkCompletedWithWrappedCFException(h2, ex);
2106	>	checkCompletedWithWrappedCFException(h3, ex);
2107	>	checkCompletedWithWrappedCFException(h4, ex);
2108	>	for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2109		}}
2110
2111		/**
2112		* acceptEither result completes exceptionally if either source cancelled
2113		*/
2114	<	public void testAcceptEither_sourceCancelled1() {
2114	>	public void testAcceptEither_sourceCancelled() {
2115		for (ExecutionMode m : ExecutionMode.values())
2116		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2117		for (Integer v1 : new Integer[] { 1, null })
2118		{
2119		final CompletableFuture<Integer> f = new CompletableFuture<>();
2120		final CompletableFuture<Integer> g = new CompletableFuture<>();
2121	<	final IncAction r = new IncAction(m);
2122	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2121	>	final NoopConsumer[] rs = new NoopConsumer[6];
2122	>	for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
2123
2124	<	assertTrue(f.cancel(mayInterruptIfRunning));
2125	<	checkCompletedWithWrappedCancellationException(h);
2126	<	g.complete(v1);
2127	<
2128	<	checkCancelled(f);
2129	<	r.assertNotInvoked();
2130	<	checkCompletedNormally(g, v1);
2131	<	checkCompletedWithWrappedCancellationException(h);
2132	<	}}
2133	<
2134	<	public void testAcceptEither_sourceCancelled2() {
2135	<	for (ExecutionMode m : ExecutionMode.values())
2136	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2100	<	for (Integer v1 : new Integer[] { 1, null })
2101	<	{
2102	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2103	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2104	<	final IncAction r = new IncAction(m);
2105	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2106	<
2107	<	assertTrue(g.cancel(mayInterruptIfRunning));
2108	<	checkCompletedWithWrappedCancellationException(h);
2109	<	f.complete(v1);
2110	<
2111	<	checkCancelled(g);
2112	<	r.assertNotInvoked();
2113	<	checkCompletedNormally(f, v1);
2114	<	checkCompletedWithWrappedCancellationException(h);
2115	<	}}
2116	<
2117	<	public void testAcceptEither_sourceCancelled3() {
2118	<	for (ExecutionMode m : ExecutionMode.values())
2119	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2120	<	for (Integer v1 : new Integer[] { 1, null })
2121	<	{
2122	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2123	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2124	<	final IncAction r = new IncAction(m);
2124	>	final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2125	>	final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2126	>	checkIncomplete(h0);
2127	>	checkIncomplete(h1);
2128	>	rs[0].assertNotInvoked();
2129	>	rs[1].assertNotInvoked();
2130	>	f.cancel(mayInterruptIfRunning);
2131	>	checkCompletedWithWrappedCancellationException(h0);
2132	>	checkCompletedWithWrappedCancellationException(h1);
2133	>	final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2134	>	final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2135	>	checkCompletedWithWrappedCancellationException(h2);
2136	>	checkCompletedWithWrappedCancellationException(h3);
2137
2138	<	assertTrue(g.cancel(mayInterruptIfRunning));
2127	<	f.complete(v1);
2128	<	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2138	>	g.complete(v1);
2139
2140	<	// unspecified behavior
2141	<	Integer v;
2140	>	// unspecified behavior - both source completions available
2141	>	final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2142	>	final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2143		try {
2144	<	assertNull(h.join());
2145	<	r.assertInvoked();
2135	<	assertEquals(inc(v1), r.value);
2144	>	assertNull(h4.join());
2145	>	rs[4].assertValue(v1);
2146		} catch (CompletionException ok) {
2147	<	checkCompletedWithWrappedCancellationException(h);
2148	<	r.assertNotInvoked();
2147	>	checkCompletedWithWrappedCancellationException(h4);
2148	>	rs[4].assertNotInvoked();
2149		}
2140	–
2141	–	checkCancelled(g);
2142	–	checkCompletedNormally(f, v1);
2143	–	}}
2144	–
2145	–	public void testAcceptEither_sourceCancelled4() {
2146	–	for (ExecutionMode m : ExecutionMode.values())
2147	–	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2148	–	for (Integer v1 : new Integer[] { 1, null })
2149	–	{
2150	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2151	–	final CompletableFuture<Integer> g = new CompletableFuture<>();
2152	–	final IncAction r = new IncAction(m);
2153	–
2154	–	assertTrue(f.cancel(mayInterruptIfRunning));
2155	–	g.complete(v1);
2156	–	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2157	–
2158	–	// unspecified behavior
2159	–	Integer v;
2150		try {
2151	<	assertNull(h.join());
2152	<	r.assertInvoked();
2163	<	assertEquals(inc(v1), r.value);
2151	>	assertNull(h5.join());
2152	>	rs[5].assertValue(v1);
2153		} catch (CompletionException ok) {
2154	<	checkCompletedWithWrappedCancellationException(h);
2155	<	r.assertNotInvoked();
2154	>	checkCompletedWithWrappedCancellationException(h5);
2155	>	rs[5].assertNotInvoked();
2156		}
2157
2158		checkCancelled(f);
2159		checkCompletedNormally(g, v1);
2160	+	checkCompletedWithWrappedCancellationException(h0);
2161	+	checkCompletedWithWrappedCancellationException(h1);
2162	+	checkCompletedWithWrappedCancellationException(h2);
2163	+	checkCompletedWithWrappedCancellationException(h3);
2164	+	for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2165		}}
2166
2167		/**
2168	<	* runAfterEither result completes normally after normal completion
2175	<	* of either source
2168	>	* acceptEither result completes exceptionally if action does
2169		*/
2170	<	public void testRunAfterEither_normalCompletion1() {
2170	>	public void testAcceptEither_actionFailed() {
2171		for (ExecutionMode m : ExecutionMode.values())
2172		for (Integer v1 : new Integer[] { 1, null })
2173		for (Integer v2 : new Integer[] { 2, null })
2174		{
2175		final CompletableFuture<Integer> f = new CompletableFuture<>();
2176		final CompletableFuture<Integer> g = new CompletableFuture<>();
2177	<	final Noop r = new Noop(m);
2178	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2177	>	final FailingConsumer[] rs = new FailingConsumer[6];
2178	>	for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
2179
2180	+	final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2181	+	final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2182		f.complete(v1);
2183	<	checkCompletedNormally(h, null);
2184	<	r.assertInvoked();
2185	<	g.complete(v2);
2183	>	final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2184	>	final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2185	>	checkCompletedWithWrappedCFException(h0);
2186	>	checkCompletedWithWrappedCFException(h1);
2187	>	checkCompletedWithWrappedCFException(h2);
2188	>	checkCompletedWithWrappedCFException(h3);
2189	>	for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2190
2191	<	checkCompletedNormally(f, v1);
2193	<	checkCompletedNormally(g, v2);
2194	<	checkCompletedNormally(h, null);
2195	<	r.assertInvoked();
2196	<	}}
2191	>	g.complete(v2);
2192
2193	<	public void testRunAfterEither_normalCompletion2() {
2194	<	for (ExecutionMode m : ExecutionMode.values())
2195	<	for (Integer v1 : new Integer[] { 1, null })
2201	<	for (Integer v2 : new Integer[] { 2, null })
2202	<	{
2203	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2204	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2205	<	final Noop r = new Noop(m);
2206	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2193	>	// unspecified behavior - both source completions available
2194	>	final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2195	>	final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2196
2197	<	g.complete(v2);
2198	<	checkCompletedNormally(h, null);
2199	<	r.assertInvoked();
2200	<	f.complete(v1);
2197	>	checkCompletedWithWrappedCFException(h4);
2198	>	assertTrue(Objects.equals(v1, rs[4].value) ||
2199	>	Objects.equals(v2, rs[4].value));
2200	>	checkCompletedWithWrappedCFException(h5);
2201	>	assertTrue(Objects.equals(v1, rs[5].value) ||
2202	>	Objects.equals(v2, rs[5].value));
2203
2204		checkCompletedNormally(f, v1);
2205		checkCompletedNormally(g, v2);
2206	<	checkCompletedNormally(h, null);
2216	<	r.assertInvoked();
2217	<	}}
2206	>	}}
2207
2208	<	public void testRunAfterEither_normalCompletion3() {
2208	>	/**
2209	>	* runAfterEither result completes normally after normal completion
2210	>	* of either source
2211	>	*/
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);
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(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);
2230	–	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2241
2242	<	checkCompletedNormally(h, null);
2242	>	final CompletableFuture<Void> h4 = m.runAfterEither(f, g, rs[4]);
2243	>	final CompletableFuture<Void> h5 = m.runAfterEither(g, f, rs[5]);
2244	>
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<>();
2248	–	final Noop r = new Noop(m);
2249	–	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);
2259	<	checkCompletedWithWrappedCFException(h, ex);
2260	<	}}
2261	<
2262	<	public void testRunAfterEither_exceptionalCompletion2() {
2263	<	for (ExecutionMode m : ExecutionMode.values())
2264	<	for (Integer v1 : new Integer[] { 1, null })
2265	<	{
2266	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2267	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2268	<	final Noop r = new Noop(m);
2269	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2270	<	final CFException ex = new CFException();
2271	<
2272	<	g.completeExceptionally(ex);
2273	<	checkCompletedWithWrappedCFException(h, ex);
2274	<	f.complete(v1);
2275	<
2276	<	r.assertNotInvoked();
2277	<	checkCompletedNormally(f, v1);
2278	<	checkCompletedWithWrappedCFException(g, ex);
2279	<	checkCompletedWithWrappedCFException(h, ex);
2280	<	}}
2281	<
2282	<	public void testRunAfterEither_exceptionalCompletion3() {
2283	<	for (ExecutionMode m : ExecutionMode.values())
2284	<	for (Integer v1 : new Integer[] { 1, null })
2285	<	{
2286	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2287	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2288	<	final Noop r = new Noop(m);
2289	<	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);
2292	<	f.complete(v1);
2293	<	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		}
2304	–
2305	–	checkCompletedWithWrappedCFException(g, ex);
2306	–	checkCompletedNormally(f, v1);
2307	–	}}
2308	–
2309	–	public void testRunAfterEither_exceptionalCompletion4() {
2310	–	for (ExecutionMode m : ExecutionMode.values())
2311	–	for (Integer v1 : new Integer[] { 1, null })
2312	–	{
2313	–	final CompletableFuture<Integer> f = new CompletableFuture<>();
2314	–	final CompletableFuture<Integer> g = new CompletableFuture<>();
2315	–	final Noop r = new Noop(m);
2316	–	final CFException ex = new CFException();
2317	–
2318	–	f.completeExceptionally(ex);
2319	–	g.complete(v1);
2320	–	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2321	–
2322	–	// unspecified behavior
2323	–	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() {
2340	<	for (ExecutionMode m : ExecutionMode.values())
2341	<	for (Integer v1 : new Integer[] { 1, null })
2342	<	for (Integer v2 : new Integer[] { 2, null })
2343	<	{
2344	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2345	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2346	<	final FailingRunnable r = new FailingRunnable(m);
2347	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2348	<
2349	<	f.complete(v1);
2350	<	checkCompletedWithWrappedCFException(h);
2351	<	g.complete(v2);
2352	<	checkCompletedNormally(f, v1);
2353	<	checkCompletedNormally(g, v2);
2354	<	}}
2355	<
2356	<	public void testRunAfterEither_actionFailed2() {
2357	<	for (ExecutionMode m : ExecutionMode.values())
2358	<	for (Integer v1 : new Integer[] { 1, null })
2359	<	for (Integer v2 : new Integer[] { 2, null })
2360	<	{
2361	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2362	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2363	<	final FailingRunnable r = new FailingRunnable(m);
2364	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2365	<
2366	<	g.complete(v2);
2367	<	checkCompletedWithWrappedCFException(h);
2368	<	f.complete(v1);
2369	<	checkCompletedNormally(f, v1);
2370	<	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() {
2377	<	for (ExecutionMode m : ExecutionMode.values())
2378	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2379	<	for (Integer v1 : new Integer[] { 1, null })
2380	<	{
2381	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2382	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2383	<	final Noop r = new Noop(m);
2384	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2385	<
2386	<	assertTrue(f.cancel(mayInterruptIfRunning));
2387	<	checkCompletedWithWrappedCancellationException(h);
2388	<	g.complete(v1);
2389	<
2390	<	checkCancelled(f);
2391	<	r.assertNotInvoked();
2392	<	checkCompletedNormally(g, v1);
2393	<	checkCompletedWithWrappedCancellationException(h);
2394	<	}}
2395	<
2396	<	public void testRunAfterEither_sourceCancelled2() {
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);
2405	<
2406	<	assertTrue(g.cancel(mayInterruptIfRunning));
2407	<	checkCompletedWithWrappedCancellationException(h);
2408	<	f.complete(v1);
2324	>	final Noop[] rs = new Noop[6];
2325	>	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
2326
2327	<	checkCancelled(g);
2328	<	r.assertNotInvoked();
2329	<	checkCompletedNormally(f, v1);
2330	<	checkCompletedWithWrappedCancellationException(h);
2331	<	}}
2332	<
2333	<	public void testRunAfterEither_sourceCancelled3() {
2334	<	for (ExecutionMode m : ExecutionMode.values())
2335	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2336	<	for (Integer v1 : new Integer[] { 1, null })
2337	<	{
2338	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
2339	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
2423	<	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));
2426	<	f.complete(v1);
2427	<	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	<	checkCompletedWithWrappedCancellationException(h);
2351	<	r.assertNotInvoked();
2350	>	checkCompletedWithWrappedCancellationException(h4);
2351	>	rs[4].assertNotInvoked();
2352	>	}
2353	>	try {
2354	>	assertNull(h5.join());
2355	>	rs[5].assertInvoked();
2356	>	} catch (CompletionException ok) {
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())
2445	–	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);
2381	<
2452	<	assertTrue(f.cancel(mayInterruptIfRunning));
2453	<	g.complete(v1);
2454	<	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2380	>	final FailingRunnable[] rs = new FailingRunnable[6];
2381	>	for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
2382
2383	<	// unspecified behavior
2384	<	Integer v;
2385	<	try {
2386	<	assertNull(h.join());
2387	<	r.assertInvoked();
2388	<	} catch (CompletionException ok) {
2389	<	checkCompletedWithWrappedCancellationException(h);
2390	<	r.assertNotInvoked();
2391	<	}
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