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.40 by jsr166, Mon Jun 2 01:11:53 2014 UTC vs.
Revision 1.41 by jsr166, Mon Jun 2 01:46:11 2014 UTC

#	Line 375 | Line 375 | public class CompletableFutureTest exten
375		}
376		}
377		static final class Noop implements Runnable {
378	+	int invocationCount = 0;
379		boolean ran;
380	<	public void run() { ran = true; }
380	>	public void run() {
381	>	invocationCount++;
382	>	ran = true;
383	>	}
384		}
385
386		static final class FailingSupplier implements Supplier<Integer> {
#	Line 954 | Line 958 | public class CompletableFutureTest exten
958
959		f.complete(v1);
960		checkIncomplete(h);
961	<	assertFalse(r.ran());
961	>	assertEquals(r.invocationCount, 0);
962		g.complete(v2);
963
964		checkCompletedNormally(h, subtract(v1, v2));
965		checkCompletedNormally(f, v1);
966		checkCompletedNormally(g, v2);
967	+	assertEquals(r.invocationCount, 1);
968		}
969		}
970
#	Line 975 | Line 980 | public class CompletableFutureTest exten
980
981		g.complete(v2);
982		checkIncomplete(h);
983	<	assertFalse(r.ran());
983	>	assertEquals(r.invocationCount, 0);
984		f.complete(v1);
985
986		checkCompletedNormally(h, subtract(v1, v2));
987		checkCompletedNormally(f, v1);
988		checkCompletedNormally(g, v2);
989	+	assertEquals(r.invocationCount, 1);
990		}
991		}
992
#	Line 1000 | Line 1006 | public class CompletableFutureTest exten
1006		checkCompletedNormally(h, subtract(v1, v2));
1007		checkCompletedNormally(f, v1);
1008		checkCompletedNormally(g, v2);
1009	+	assertEquals(r.invocationCount, 1);
1010		}
1011		}
1012
#	Line 1019 | Line 1026 | public class CompletableFutureTest exten
1026		checkCompletedNormally(h, subtract(v1, v2));
1027		checkCompletedNormally(f, v1);
1028		checkCompletedNormally(g, v2);
1029	+	assertEquals(r.invocationCount, 1);
1030		}
1031		}
1032
#	Line 1042 | Line 1050 | public class CompletableFutureTest exten
1050
1051		checkCompletedWithWrappedCFException(h, ex);
1052		checkCompletedWithWrappedCFException(f, ex);
1053	<	assertFalse(r.ran());
1053	>	assertEquals(r.invocationCount, 0);
1054		checkCompletedNormally(g, v1);
1055		}
1056		}
#	Line 1063 | Line 1071 | public class CompletableFutureTest exten
1071
1072		checkCompletedWithWrappedCFException(h, ex);
1073		checkCompletedWithWrappedCFException(g, ex);
1074	<	assertFalse(r.ran());
1074	>	assertEquals(r.invocationCount, 0);
1075		checkCompletedNormally(f, v1);
1076		}
1077		}
#	Line 1083 | Line 1091 | public class CompletableFutureTest exten
1091
1092		checkCompletedWithWrappedCFException(h, ex);
1093		checkCompletedWithWrappedCFException(g, ex);
1094	<	assertFalse(r.ran());
1094	>	assertEquals(r.invocationCount, 0);
1095		checkCompletedNormally(f, v1);
1096		}
1097		}
#	Line 1103 | Line 1111 | public class CompletableFutureTest exten
1111
1112		checkCompletedWithWrappedCFException(h, ex);
1113		checkCompletedWithWrappedCFException(f, ex);
1114	<	assertFalse(r.ran());
1114	>	assertEquals(r.invocationCount, 0);
1115		checkCompletedNormally(g, v1);
1116		}
1117		}
#	Line 1170 | Line 1178 | public class CompletableFutureTest exten
1178
1179		checkCompletedWithWrappedCancellationException(h);
1180		checkCancelled(f);
1181	<	assertFalse(r.ran());
1181	>	assertEquals(r.invocationCount, 0);
1182		checkCompletedNormally(g, v1);
1183		}
1184		}
#	Line 1191 | Line 1199 | public class CompletableFutureTest exten
1199
1200		checkCompletedWithWrappedCancellationException(h);
1201		checkCancelled(g);
1202	<	assertFalse(r.ran());
1202	>	assertEquals(r.invocationCount, 0);
1203		checkCompletedNormally(f, v1);
1204		}
1205		}
#	Line 1211 | Line 1219 | public class CompletableFutureTest exten
1219
1220		checkCompletedWithWrappedCancellationException(h);
1221		checkCancelled(g);
1222	<	assertFalse(r.ran());
1222	>	assertEquals(r.invocationCount, 0);
1223		checkCompletedNormally(f, v1);
1224		}
1225		}
#	Line 1231 | Line 1239 | public class CompletableFutureTest exten
1239
1240		checkCompletedWithWrappedCancellationException(h);
1241		checkCancelled(f);
1242	<	assertFalse(r.ran());
1242	>	assertEquals(r.invocationCount, 0);
1243		checkCompletedNormally(g, v1);
1244		}
1245		}
#	Line 1344 | Line 1352 | public class CompletableFutureTest exten
1352
1353		checkCompletedWithWrappedCFException(h, ex);
1354		checkCompletedWithWrappedCFException(f, ex);
1355	<	assertFalse(r.ran());
1355	>	assertEquals(r.invocationCount, 0);
1356		checkCompletedNormally(g, v1);
1357		}
1358		}
#	Line 1365 | Line 1373 | public class CompletableFutureTest exten
1373
1374		checkCompletedWithWrappedCFException(h, ex);
1375		checkCompletedWithWrappedCFException(g, ex);
1376	<	assertFalse(r.ran());
1376	>	assertEquals(r.invocationCount, 0);
1377		checkCompletedNormally(f, v1);
1378		}
1379		}
#	Line 1385 | Line 1393 | public class CompletableFutureTest exten
1393
1394		checkCompletedWithWrappedCFException(h, ex);
1395		checkCompletedWithWrappedCFException(g, ex);
1396	<	assertFalse(r.ran());
1396	>	assertEquals(r.invocationCount, 0);
1397		checkCompletedNormally(f, v1);
1398		}
1399		}
#	Line 1472 | Line 1480 | public class CompletableFutureTest exten
1480
1481		checkCompletedWithWrappedCancellationException(h);
1482		checkCancelled(f);
1483	<	assertFalse(r.ran());
1483	>	assertEquals(r.invocationCount, 0);
1484		checkCompletedNormally(g, v1);
1485		}
1486		}
#	Line 1493 | Line 1501 | public class CompletableFutureTest exten
1501
1502		checkCompletedWithWrappedCancellationException(h);
1503		checkCancelled(g);
1504	<	assertFalse(r.ran());
1504	>	assertEquals(r.invocationCount, 0);
1505		checkCompletedNormally(f, v1);
1506		}
1507		}
#	Line 1513 | Line 1521 | public class CompletableFutureTest exten
1521
1522		checkCompletedWithWrappedCancellationException(h);
1523		checkCancelled(g);
1524	<	assertFalse(r.ran());
1524	>	assertEquals(r.invocationCount, 0);
1525		checkCompletedNormally(f, v1);
1526		}
1527		}
#	Line 1533 | Line 1541 | public class CompletableFutureTest exten
1541
1542		checkCompletedWithWrappedCancellationException(h);
1543		checkCancelled(f);
1544	<	assertFalse(r.ran());
1544	>	assertEquals(r.invocationCount, 0);
1545		checkCompletedNormally(g, v1);
1546		}
1547		}
#	Line 1558 | Line 1566 | public class CompletableFutureTest exten
1566		g.complete(v2);
1567
1568		checkCompletedNormally(h, null);
1569	<	assertTrue(r.ran);
1569	>	assertEquals(r.invocationCount, 1);
1570		checkCompletedNormally(f, v1);
1571		checkCompletedNormally(g, v2);
1572		}
#	Line 1580 | Line 1588 | public class CompletableFutureTest exten
1588		f.complete(v1);
1589
1590		checkCompletedNormally(h, null);
1591	<	assertTrue(r.ran);
1591	>	assertEquals(r.invocationCount, 1);
1592		checkCompletedNormally(f, v1);
1593		checkCompletedNormally(g, v2);
1594		}
#	Line 1620 | Line 1628 | public class CompletableFutureTest exten
1628		final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1629
1630		checkCompletedNormally(h, null);
1631	<	assertTrue(r.ran);
1631	>	assertEquals(r.invocationCount, 1);
1632		checkCompletedNormally(f, v1);
1633		checkCompletedNormally(g, v2);
1634		}
#	Line 1646 | Line 1654 | public class CompletableFutureTest exten
1654
1655		checkCompletedWithWrappedCFException(h, ex);
1656		checkCompletedWithWrappedCFException(f, ex);
1657	<	assertFalse(r.ran);
1657	>	assertEquals(r.invocationCount, 0);
1658		checkCompletedNormally(g, v1);
1659		}
1660		}
#	Line 1667 | Line 1675 | public class CompletableFutureTest exten
1675
1676		checkCompletedWithWrappedCFException(h, ex);
1677		checkCompletedWithWrappedCFException(g, ex);
1678	<	assertFalse(r.ran);
1678	>	assertEquals(r.invocationCount, 0);
1679		checkCompletedNormally(f, v1);
1680		}
1681		}
#	Line 1687 | Line 1695 | public class CompletableFutureTest exten
1695
1696		checkCompletedWithWrappedCFException(h, ex);
1697		checkCompletedWithWrappedCFException(g, ex);
1698	<	assertFalse(r.ran);
1698	>	assertEquals(r.invocationCount, 0);
1699		checkCompletedNormally(f, v1);
1700		}
1701		}
#	Line 1707 | Line 1715 | public class CompletableFutureTest exten
1715
1716		checkCompletedWithWrappedCFException(h, ex);
1717		checkCompletedWithWrappedCFException(f, ex);
1718	<	assertFalse(r.ran);
1718	>	assertEquals(r.invocationCount, 0);
1719		checkCompletedNormally(g, v1);
1720		}
1721		}
#	Line 1774 | Line 1782 | public class CompletableFutureTest exten
1782
1783		checkCompletedWithWrappedCancellationException(h);
1784		checkCancelled(f);
1785	<	assertFalse(r.ran);
1785	>	assertEquals(r.invocationCount, 0);
1786		checkCompletedNormally(g, v1);
1787		}
1788		}
#	Line 1795 | Line 1803 | public class CompletableFutureTest exten
1803
1804		checkCompletedWithWrappedCancellationException(h);
1805		checkCancelled(g);
1806	<	assertFalse(r.ran);
1806	>	assertEquals(r.invocationCount, 0);
1807		checkCompletedNormally(f, v1);
1808		}
1809		}
#	Line 1815 | Line 1823 | public class CompletableFutureTest exten
1823
1824		checkCompletedWithWrappedCancellationException(h);
1825		checkCancelled(g);
1826	<	assertFalse(r.ran);
1826	>	assertEquals(r.invocationCount, 0);
1827		checkCompletedNormally(f, v1);
1828		}
1829		}
#	Line 1835 | Line 1843 | public class CompletableFutureTest exten
1843
1844		checkCompletedWithWrappedCancellationException(h);
1845		checkCancelled(f);
1846	<	assertFalse(r.ran);
1846	>	assertEquals(r.invocationCount, 0);
1847		checkCompletedNormally(g, v1);
1848		}
1849		}
#	Line 1902 | Line 1910 | public class CompletableFutureTest exten
1910		// unspecified behavior
1911		assertTrue(Objects.equals(h.join(), inc(v1)) ||
1912		Objects.equals(h.join(), inc(v2)));
1913	+	assertEquals(r.invocationCount, 1);
1914		}
1915		}
1916
#	Line 1923 | Line 1932 | public class CompletableFutureTest exten
1932		checkCompletedWithWrappedCFException(h, ex);
1933		g.complete(v1);
1934
1935	<	assertFalse(r.ran());
1935	>	assertEquals(r.invocationCount, 0);
1936		checkCompletedNormally(g, v1);
1937		checkCompletedWithWrappedCFException(f, ex);
1938		checkCompletedWithWrappedCFException(h, ex);
#	Line 1944 | Line 1953 | public class CompletableFutureTest exten
1953		checkCompletedWithWrappedCFException(h, ex);
1954		f.complete(v1);
1955
1956	<	assertFalse(r.ran());
1956	>	assertEquals(r.invocationCount, 0);
1957		checkCompletedNormally(f, v1);
1958		checkCompletedWithWrappedCFException(g, ex);
1959		checkCompletedWithWrappedCFException(h, ex);
#	Line 1968 | Line 1977 | public class CompletableFutureTest exten
1977		Integer v;
1978		try {
1979		assertEquals(h.join(), inc(v1));
1980	<	assertTrue(r.ran());
1980	>	assertEquals(r.invocationCount, 1);
1981		} catch (CompletionException ok) {
1982		checkCompletedWithWrappedCFException(h, ex);
1983	<	assertFalse(r.ran());
1983	>	assertEquals(r.invocationCount, 0);
1984		}
1985
1986		checkCompletedWithWrappedCFException(g, ex);
#	Line 1996 | Line 2005 | public class CompletableFutureTest exten
2005		Integer v;
2006		try {
2007		assertEquals(h.join(), inc(v1));
2008	<	assertTrue(r.ran());
2008	>	assertEquals(r.invocationCount, 1);
2009		} catch (CompletionException ok) {
2010		checkCompletedWithWrappedCFException(h, ex);
2011	<	assertFalse(r.ran());
2011	>	assertEquals(r.invocationCount, 0);
2012		}
2013
2014		checkCompletedWithWrappedCFException(f, ex);
2006	–	assertFalse(r.ran());
2015		checkCompletedNormally(g, v1);
2016		}
2017		}
#	Line 2065 | Line 2073 | public class CompletableFutureTest exten
2073		g.complete(v1);
2074
2075		checkCancelled(f);
2076	<	assertFalse(r.ran());
2076	>	assertEquals(r.invocationCount, 0);
2077		checkCompletedNormally(g, v1);
2078		checkCompletedWithWrappedCancellationException(h);
2079		}
#	Line 2086 | Line 2094 | public class CompletableFutureTest exten
2094		f.complete(v1);
2095
2096		checkCancelled(g);
2097	<	assertFalse(r.ran());
2097	>	assertEquals(r.invocationCount, 0);
2098		checkCompletedNormally(f, v1);
2099		checkCompletedWithWrappedCancellationException(h);
2100		}
#	Line 2109 | Line 2117 | public class CompletableFutureTest exten
2117		Integer v;
2118		try {
2119		assertEquals(h.join(), inc(v1));
2120	<	assertTrue(r.ran());
2120	>	assertEquals(r.invocationCount, 1);
2121		} catch (CompletionException ok) {
2122		checkCompletedWithWrappedCancellationException(h);
2123	<	assertFalse(r.ran());
2123	>	assertEquals(r.invocationCount, 0);
2124		}
2125
2126		checkCancelled(g);
#	Line 2137 | Line 2145 | public class CompletableFutureTest exten
2145		Integer v;
2146		try {
2147		assertEquals(h.join(), inc(v1));
2148	<	assertTrue(r.ran());
2148	>	assertEquals(r.invocationCount, 1);
2149		} catch (CompletionException ok) {
2150		checkCompletedWithWrappedCancellationException(h);
2151	<	assertFalse(r.ran());
2151	>	assertEquals(r.invocationCount, 0);
2152		}
2153
2154		checkCancelled(f);
#	Line 2234 | Line 2242 | public class CompletableFutureTest exten
2242		checkCompletedWithWrappedCFException(h, ex);
2243		g.complete(v1);
2244
2245	<	assertFalse(r.ran());
2245	>	assertEquals(r.invocationCount, 0);
2246		checkCompletedNormally(g, v1);
2247		checkCompletedWithWrappedCFException(f, ex);
2248		checkCompletedWithWrappedCFException(h, ex);
#	Line 2255 | Line 2263 | public class CompletableFutureTest exten
2263		checkCompletedWithWrappedCFException(h, ex);
2264		f.complete(v1);
2265
2266	<	assertFalse(r.ran());
2266	>	assertEquals(r.invocationCount, 0);
2267		checkCompletedNormally(f, v1);
2268		checkCompletedWithWrappedCFException(g, ex);
2269		checkCompletedWithWrappedCFException(h, ex);
#	Line 2279 | Line 2287 | public class CompletableFutureTest exten
2287		Integer v;
2288		try {
2289		assertEquals(h.join(), null);
2290	<	assertTrue(r.ran());
2290	>	assertEquals(r.invocationCount, 1);
2291		assertEquals(inc(v1), r.value);
2292		} catch (CompletionException ok) {
2293		checkCompletedWithWrappedCFException(h, ex);
2294	<	assertFalse(r.ran());
2294	>	assertEquals(r.invocationCount, 0);
2295		}
2296
2297		checkCompletedWithWrappedCFException(g, ex);
#	Line 2308 | Line 2316 | public class CompletableFutureTest exten
2316		Integer v;
2317		try {
2318		assertEquals(h.join(), null);
2319	<	assertTrue(r.ran());
2319	>	assertEquals(r.invocationCount, 1);
2320		assertEquals(inc(v1), r.value);
2321		} catch (CompletionException ok) {
2322		checkCompletedWithWrappedCFException(h, ex);
2323	<	assertFalse(r.ran());
2323	>	assertEquals(r.invocationCount, 0);
2324		}
2325
2326		checkCompletedWithWrappedCFException(f, ex);
2319	–	assertFalse(r.ran());
2327		checkCompletedNormally(g, v1);
2328		}
2329		}
#	Line 2378 | Line 2385 | public class CompletableFutureTest exten
2385		g.complete(v1);
2386
2387		checkCancelled(f);
2388	<	assertFalse(r.ran());
2388	>	assertEquals(r.invocationCount, 0);
2389		checkCompletedNormally(g, v1);
2390		checkCompletedWithWrappedCancellationException(h);
2391		}
#	Line 2399 | Line 2406 | public class CompletableFutureTest exten
2406		f.complete(v1);
2407
2408		checkCancelled(g);
2409	<	assertFalse(r.ran());
2409	>	assertEquals(r.invocationCount, 0);
2410		checkCompletedNormally(f, v1);
2411		checkCompletedWithWrappedCancellationException(h);
2412		}
#	Line 2422 | Line 2429 | public class CompletableFutureTest exten
2429		Integer v;
2430		try {
2431		assertEquals(h.join(), null);
2432	<	assertTrue(r.ran());
2432	>	assertEquals(r.invocationCount, 1);
2433		assertEquals(inc(v1), r.value);
2434		} catch (CompletionException ok) {
2435		checkCompletedWithWrappedCancellationException(h);
2436	<	assertFalse(r.ran());
2436	>	assertEquals(r.invocationCount, 0);
2437		}
2438
2439		checkCancelled(g);
#	Line 2451 | Line 2458 | public class CompletableFutureTest exten
2458		Integer v;
2459		try {
2460		assertEquals(h.join(), null);
2461	<	assertTrue(r.ran());
2461	>	assertEquals(r.invocationCount, 1);
2462		assertEquals(inc(v1), r.value);
2463		} catch (CompletionException ok) {
2464		checkCompletedWithWrappedCancellationException(h);
2465	<	assertFalse(r.ran());
2465	>	assertEquals(r.invocationCount, 0);
2466		}
2467
2468		checkCancelled(f);
#	Line 2467 | Line 2474 | public class CompletableFutureTest exten
2474		* runAfterEither result completes normally after normal completion
2475		* of either source
2476		*/
2477	<	public void testRunAfterEither() {
2478	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2479	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2480	<	Noop r = new Noop();
2474	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2475	<	f.complete(one);
2476	<	checkCompletedNormally(g, null);
2477	<	f2.complete(one);
2478	<	checkCompletedNormally(g, null);
2479	<	assertTrue(r.ran);
2477	>	public void testRunAfterEither_normalCompletion1() {
2478	>	for (ExecutionMode m : ExecutionMode.values())
2479	>	for (Integer v1 : new Integer[] { 1, null })
2480	>	for (Integer v2 : new Integer[] { 2, null }) {
2481
2482	<	r = new Noop();
2483	<	f = new CompletableFuture<>();
2484	<	f.complete(one);
2485	<	f2 = new CompletableFuture<>();
2486	<	g = f.runAfterEither(f2, r);
2487	<	checkCompletedNormally(g, null);
2488	<	assertTrue(r.ran);
2482	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2483	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2484	>	final Noop r = new Noop();
2485	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2486	>
2487	>	f.complete(v1);
2488	>	checkCompletedNormally(h, null);
2489	>	assertEquals(r.invocationCount, 1);
2490	>	g.complete(v2);
2491	>
2492	>	checkCompletedNormally(f, v1);
2493	>	checkCompletedNormally(g, v2);
2494	>	checkCompletedNormally(h, null);
2495	>	assertEquals(r.invocationCount, 1);
2496	>	}
2497	>	}
2498	>
2499	>	public void testRunAfterEither_normalCompletion2() {
2500	>	for (ExecutionMode m : ExecutionMode.values())
2501	>	for (Integer v1 : new Integer[] { 1, null })
2502	>	for (Integer v2 : new Integer[] { 2, null }) {
2503	>
2504	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2505	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2506	>	final Noop r = new Noop();
2507	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2508	>
2509	>	g.complete(v2);
2510	>	checkCompletedNormally(h, null);
2511	>	assertEquals(r.invocationCount, 1);
2512	>	f.complete(v1);
2513	>
2514	>	checkCompletedNormally(f, v1);
2515	>	checkCompletedNormally(g, v2);
2516	>	checkCompletedNormally(h, null);
2517	>	assertEquals(r.invocationCount, 1);
2518	>	}
2519	>	}
2520	>	public void testRunAfterEither_normalCompletion3() {
2521	>	for (ExecutionMode m : ExecutionMode.values())
2522	>	for (Integer v1 : new Integer[] { 1, null })
2523	>	for (Integer v2 : new Integer[] { 2, null }) {
2524	>
2525	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2526	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2527	>	final Noop r = new Noop();
2528	>
2529	>	f.complete(v1);
2530	>	g.complete(v2);
2531	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2532	>
2533	>	checkCompletedNormally(h, null);
2534	>	checkCompletedNormally(f, v1);
2535	>	checkCompletedNormally(g, v2);
2536	>	assertEquals(r.invocationCount, 1);
2537	>	}
2538		}
2539
2540		/**
2541		* runAfterEither result completes exceptionally after exceptional
2542		* completion of either source
2543		*/
2544	<	public void testRunAfterEither2() {
2545	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2546	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2497	<	Noop r = new Noop();
2498	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2499	<	f.completeExceptionally(new CFException());
2500	<	f2.complete(one);
2501	<	checkCompletedWithWrappedCFException(g);
2544	>	public void testRunAfterEither_exceptionalCompletion1() {
2545	>	for (ExecutionMode m : ExecutionMode.values())
2546	>	for (Integer v1 : new Integer[] { 1, null }) {
2547
2548	<	r = new Noop();
2549	<	f = new CompletableFuture<>();
2550	<	f2 = new CompletableFuture<>();
2551	<	f2.completeExceptionally(new CFException());
2552	<	g = f.runAfterEither(f2, r);
2553	<	checkCompletedWithWrappedCFException(g);
2548	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2549	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2550	>	final Noop r = new Noop();
2551	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2552	>	final CFException ex = new CFException();
2553	>
2554	>	f.completeExceptionally(ex);
2555	>	checkCompletedWithWrappedCFException(h, ex);
2556	>	g.complete(v1);
2557	>
2558	>	assertEquals(r.invocationCount, 0);
2559	>	checkCompletedNormally(g, v1);
2560	>	checkCompletedWithWrappedCFException(f, ex);
2561	>	checkCompletedWithWrappedCFException(h, ex);
2562	>	}
2563	>	}
2564	>
2565	>	public void testRunAfterEither_exceptionalCompletion2() {
2566	>	for (ExecutionMode m : ExecutionMode.values())
2567	>	for (Integer v1 : new Integer[] { 1, null }) {
2568	>
2569	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2570	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2571	>	final Noop r = new Noop();
2572	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2573	>	final CFException ex = new CFException();
2574	>
2575	>	g.completeExceptionally(ex);
2576	>	checkCompletedWithWrappedCFException(h, ex);
2577	>	f.complete(v1);
2578	>
2579	>	assertEquals(r.invocationCount, 0);
2580	>	checkCompletedNormally(f, v1);
2581	>	checkCompletedWithWrappedCFException(g, ex);
2582	>	checkCompletedWithWrappedCFException(h, ex);
2583	>	}
2584	>	}
2585	>
2586	>	public void testRunAfterEither_exceptionalCompletion3() {
2587	>	for (ExecutionMode m : ExecutionMode.values())
2588	>	for (Integer v1 : new Integer[] { 1, null }) {
2589	>
2590	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2591	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2592	>	final Noop r = new Noop();
2593	>	final CFException ex = new CFException();
2594	>
2595	>	g.completeExceptionally(ex);
2596	>	f.complete(v1);
2597	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2598	>
2599	>	// unspecified behavior
2600	>	Integer v;
2601	>	try {
2602	>	assertEquals(h.join(), null);
2603	>	assertEquals(r.invocationCount, 1);
2604	>	} catch (CompletionException ok) {
2605	>	checkCompletedWithWrappedCFException(h, ex);
2606	>	assertEquals(r.invocationCount, 0);
2607	>	}
2608	>
2609	>	checkCompletedWithWrappedCFException(g, ex);
2610	>	checkCompletedNormally(f, v1);
2611	>	}
2612	>	}
2613	>
2614	>	public void testRunAfterEither_exceptionalCompletion4() {
2615	>	for (ExecutionMode m : ExecutionMode.values())
2616	>	for (Integer v1 : new Integer[] { 1, null }) {
2617	>
2618	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2619	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2620	>	final Noop r = new Noop();
2621	>	final CFException ex = new CFException();
2622	>
2623	>	f.completeExceptionally(ex);
2624	>	g.complete(v1);
2625	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2626	>
2627	>	// unspecified behavior
2628	>	Integer v;
2629	>	try {
2630	>	assertEquals(h.join(), null);
2631	>	assertEquals(r.invocationCount, 1);
2632	>	} catch (CompletionException ok) {
2633	>	checkCompletedWithWrappedCFException(h, ex);
2634	>	assertEquals(r.invocationCount, 0);
2635	>	}
2636	>
2637	>	checkCompletedWithWrappedCFException(f, ex);
2638	>	checkCompletedNormally(g, v1);
2639	>	}
2640		}
2641
2642		/**
2643		* runAfterEither result completes exceptionally if action does
2644		*/
2645	<	public void testRunAfterEither3() {
2646	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2647	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2648	<	FailingNoop r = new FailingNoop();
2649	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2650	<	f2.complete(two);
2651	<	checkCompletedWithWrappedCFException(g);
2645	>	public void testRunAfterEither_actionFailed1() {
2646	>	for (ExecutionMode m : ExecutionMode.values())
2647	>	for (Integer v1 : new Integer[] { 1, null })
2648	>	for (Integer v2 : new Integer[] { 2, null }) {
2649	>
2650	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2651	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2652	>	final FailingNoop r = new FailingNoop();
2653	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2654	>
2655	>	f.complete(v1);
2656	>	checkCompletedWithWrappedCFException(h);
2657	>	g.complete(v2);
2658	>	checkCompletedNormally(f, v1);
2659	>	checkCompletedNormally(g, v2);
2660	>	}
2661	>	}
2662	>
2663	>	public void testRunAfterEither_actionFailed2() {
2664	>	for (ExecutionMode m : ExecutionMode.values())
2665	>	for (Integer v1 : new Integer[] { 1, null })
2666	>	for (Integer v2 : new Integer[] { 2, null }) {
2667	>
2668	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2669	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2670	>	final FailingNoop r = new FailingNoop();
2671	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2672	>
2673	>	g.complete(v2);
2674	>	checkCompletedWithWrappedCFException(h);
2675	>	f.complete(v1);
2676	>	checkCompletedNormally(f, v1);
2677	>	checkCompletedNormally(g, v2);
2678	>	}
2679		}
2680
2681		/**
2682		* runAfterEither result completes exceptionally if either source cancelled
2683		*/
2684	<	public void testRunAfterEither4() {
2685	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2686	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2687	<	Noop r = new Noop();
2688	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2689	<	assertTrue(f.cancel(true));
2690	<	checkCompletedWithWrappedCancellationException(g);
2691	<	f = new CompletableFuture<>();
2692	<	f2 = new CompletableFuture<>();
2693	<	assertTrue(f2.cancel(true));
2694	<	checkCompletedWithWrappedCancellationException(g);
2684	>	public void testRunAfterEither_sourceCancelled1() {
2685	>	for (ExecutionMode m : ExecutionMode.values())
2686	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2687	>	for (Integer v1 : new Integer[] { 1, null }) {
2688	>
2689	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2690	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2691	>	final Noop r = new Noop();
2692	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2693	>
2694	>	assertTrue(f.cancel(mayInterruptIfRunning));
2695	>	checkCompletedWithWrappedCancellationException(h);
2696	>	g.complete(v1);
2697	>
2698	>	checkCancelled(f);
2699	>	assertEquals(r.invocationCount, 0);
2700	>	checkCompletedNormally(g, v1);
2701	>	checkCompletedWithWrappedCancellationException(h);
2702	>	}
2703	>	}
2704	>
2705	>	public void testRunAfterEither_sourceCancelled2() {
2706	>	for (ExecutionMode m : ExecutionMode.values())
2707	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2708	>	for (Integer v1 : new Integer[] { 1, null }) {
2709	>
2710	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2711	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2712	>	final Noop r = new Noop();
2713	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2714	>
2715	>	assertTrue(g.cancel(mayInterruptIfRunning));
2716	>	checkCompletedWithWrappedCancellationException(h);
2717	>	f.complete(v1);
2718	>
2719	>	checkCancelled(g);
2720	>	assertEquals(r.invocationCount, 0);
2721	>	checkCompletedNormally(f, v1);
2722	>	checkCompletedWithWrappedCancellationException(h);
2723	>	}
2724	>	}
2725	>
2726	>	public void testRunAfterEither_sourceCancelled3() {
2727	>	for (ExecutionMode m : ExecutionMode.values())
2728	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2729	>	for (Integer v1 : new Integer[] { 1, null }) {
2730	>
2731	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2732	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2733	>	final Noop r = new Noop();
2734	>
2735	>	assertTrue(g.cancel(mayInterruptIfRunning));
2736	>	f.complete(v1);
2737	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2738	>
2739	>	// unspecified behavior
2740	>	Integer v;
2741	>	try {
2742	>	assertEquals(h.join(), null);
2743	>	assertEquals(r.invocationCount, 1);
2744	>	} catch (CompletionException ok) {
2745	>	checkCompletedWithWrappedCancellationException(h);
2746	>	assertEquals(r.invocationCount, 0);
2747	>	}
2748	>
2749	>	checkCancelled(g);
2750	>	checkCompletedNormally(f, v1);
2751	>	}
2752	>	}
2753	>
2754	>	public void testRunAfterEither_sourceCancelled4() {
2755	>	for (ExecutionMode m : ExecutionMode.values())
2756	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2757	>	for (Integer v1 : new Integer[] { 1, null }) {
2758	>
2759	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2760	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2761	>	final Noop r = new Noop();
2762	>
2763	>	assertTrue(f.cancel(mayInterruptIfRunning));
2764	>	g.complete(v1);
2765	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2766	>
2767	>	// unspecified behavior
2768	>	Integer v;
2769	>	try {
2770	>	assertEquals(h.join(), null);
2771	>	assertEquals(r.invocationCount, 1);
2772	>	} catch (CompletionException ok) {
2773	>	checkCompletedWithWrappedCancellationException(h);
2774	>	assertEquals(r.invocationCount, 0);
2775	>	}
2776	>
2777	>	checkCancelled(f);
2778	>	checkCompletedNormally(g, v1);
2779	>	}
2780		}
2781
2782		/**
#	Line 2759 | Line 3002 | public class CompletableFutureTest exten
3002		}
3003
3004		/**
2762	–	* runAfterEitherAsync result completes normally after normal
2763	–	* completion of sources
2764	–	*/
2765	–	public void testRunAfterEitherAsync() {
2766	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2767	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2768	–	Noop r = new Noop();
2769	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2770	–	f.complete(one);
2771	–	checkCompletedNormally(g, null);
2772	–	assertTrue(r.ran);
2773	–
2774	–	r = new Noop();
2775	–	f = new CompletableFuture<>();
2776	–	f.complete(one);
2777	–	f2 = new CompletableFuture<>();
2778	–	g = f.runAfterEitherAsync(f2, r);
2779	–	checkCompletedNormally(g, null);
2780	–	assertTrue(r.ran);
2781	–	}
2782	–
2783	–	/**
2784	–	* runAfterEitherAsync result completes exceptionally after exceptional
2785	–	* completion of source
2786	–	*/
2787	–	public void testRunAfterEitherAsync2() {
2788	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2789	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2790	–	Noop r = new Noop();
2791	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2792	–	f.completeExceptionally(new CFException());
2793	–	checkCompletedWithWrappedCFException(g);
2794	–
2795	–	r = new Noop();
2796	–	f = new CompletableFuture<>();
2797	–	f2 = new CompletableFuture<>();
2798	–	f2.completeExceptionally(new CFException());
2799	–	g = f.runAfterEitherAsync(f2, r);
2800	–	f.complete(one);
2801	–	checkCompletedWithWrappedCFException(g);
2802	–	}
2803	–
2804	–	/**
2805	–	* runAfterEitherAsync result completes exceptionally if action does
2806	–	*/
2807	–	public void testRunAfterEitherAsync3() {
2808	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2809	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2810	–	FailingNoop r = new FailingNoop();
2811	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2812	–	f.complete(one);
2813	–	checkCompletedWithWrappedCFException(g);
2814	–	}
2815	–
2816	–	/**
2817	–	* runAfterEitherAsync result completes exceptionally if either
2818	–	* source cancelled
2819	–	*/
2820	–	public void testRunAfterEitherAsync4() {
2821	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2822	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2823	–	Noop r = new Noop();
2824	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2825	–	assertTrue(f.cancel(true));
2826	–	checkCompletedWithWrappedCancellationException(g);
2827	–
2828	–	r = new Noop();
2829	–	f = new CompletableFuture<>();
2830	–	f2 = new CompletableFuture<>();
2831	–	assertTrue(f2.cancel(true));
2832	–	g = f.runAfterEitherAsync(f2, r);
2833	–	checkCompletedWithWrappedCancellationException(g);
2834	–	}
2835	–
2836	–	/**
3005		* thenComposeAsync result completes normally after normal
3006		* completion of source
3007		*/
#	Line 3056 | Line 3224 | public class CompletableFutureTest exten
3224		checkCompletedWithWrappedCancellationException(g);
3225		}
3226
3059	–	/**
3060	–	* runAfterEitherAsync result completes normally after normal
3061	–	* completion of sources
3062	–	*/
3063	–	public void testRunAfterEitherAsyncE() {
3064	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3065	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3066	–	Noop r = new Noop();
3067	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3068	–	f.complete(one);
3069	–	checkCompletedNormally(g, null);
3070	–	assertTrue(r.ran);
3071	–
3072	–	r = new Noop();
3073	–	f = new CompletableFuture<>();
3074	–	f.complete(one);
3075	–	f2 = new CompletableFuture<>();
3076	–	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3077	–	checkCompletedNormally(g, null);
3078	–	assertTrue(r.ran);
3079	–	}
3080	–
3081	–	/**
3082	–	* runAfterEitherAsync result completes exceptionally after exceptional
3083	–	* completion of source
3084	–	*/
3085	–	public void testRunAfterEitherAsync2E() {
3086	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3087	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3088	–	Noop r = new Noop();
3089	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3090	–	f.completeExceptionally(new CFException());
3091	–	checkCompletedWithWrappedCFException(g);
3092	–
3093	–	r = new Noop();
3094	–	f = new CompletableFuture<>();
3095	–	f2 = new CompletableFuture<>();
3096	–	f2.completeExceptionally(new CFException());
3097	–	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3098	–	f.complete(one);
3099	–	checkCompletedWithWrappedCFException(g);
3100	–	}
3101	–
3102	–	/**
3103	–	* runAfterEitherAsync result completes exceptionally if action does
3104	–	*/
3105	–	public void testRunAfterEitherAsync3E() {
3106	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3107	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3108	–	FailingNoop r = new FailingNoop();
3109	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3110	–	f.complete(one);
3111	–	checkCompletedWithWrappedCFException(g);
3112	–	}
3113	–
3114	–	/**
3115	–	* runAfterEitherAsync result completes exceptionally if either
3116	–	* source cancelled
3117	–	*/
3118	–	public void testRunAfterEitherAsync4E() {
3119	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3120	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3121	–	Noop r = new Noop();
3122	–	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3123	–	assertTrue(f.cancel(true));
3124	–	checkCompletedWithWrappedCancellationException(g);
3125	–
3126	–	r = new Noop();
3127	–	f = new CompletableFuture<>();
3128	–	f2 = new CompletableFuture<>();
3129	–	assertTrue(f2.cancel(true));
3130	–	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3131	–	checkCompletedWithWrappedCancellationException(g);
3132	–	}
3133	–
3227		/**
3228		* thenComposeAsync result completes normally after normal
3229		* completion of source

Diff Legend

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