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.81 by jsr166, Mon Jun 16 17:41:26 2014 UTC vs.
Revision 1.93 by jsr166, Tue Jun 17 21:09:56 2014 UTC

#	Line 1264 | Line 1264 | public class CompletableFutureTest exten
1264		*/
1265		public void testThenRun_normalCompletion() {
1266		for (ExecutionMode m : ExecutionMode.values())
1267	–	for (boolean createIncomplete : new boolean[] { true, false })
1267		for (Integer v1 : new Integer[] { 1, null })
1268		{
1269		final CompletableFuture<Integer> f = new CompletableFuture<>();
1270	<	final Noop r = new Noop(m);
1271	<	if (!createIncomplete) assertTrue(f.complete(v1));
1273	<	final CompletableFuture<Void> g = m.thenRun(f, r);
1274	<	if (createIncomplete) {
1275	<	checkIncomplete(g);
1276	<	assertTrue(f.complete(v1));
1277	<	}
1270	>	final Noop[] rs = new Noop[6];
1271	>	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1272
1273	<	checkCompletedNormally(g, null);
1273	>	final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1274	>	final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1275	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1276	>	checkIncomplete(h0);
1277	>	checkIncomplete(h1);
1278	>	checkIncomplete(h2);
1279	>	assertTrue(f.complete(v1));
1280	>	final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1281	>	final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1282	>	final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1283	>
1284	>	checkCompletedNormally(h0, null);
1285	>	checkCompletedNormally(h1, null);
1286	>	checkCompletedNormally(h2, null);
1287	>	checkCompletedNormally(h3, null);
1288	>	checkCompletedNormally(h4, null);
1289	>	checkCompletedNormally(h5, null);
1290		checkCompletedNormally(f, v1);
1291	<	r.assertInvoked();
1291	>	for (Noop r : rs) r.assertInvoked();
1292		}}
1293
1294		/**
#	Line 1287 | Line 1297 | public class CompletableFutureTest exten
1297		*/
1298		public void testThenRun_exceptionalCompletion() {
1299		for (ExecutionMode m : ExecutionMode.values())
1290	–	for (boolean createIncomplete : new boolean[] { true, false })
1300		{
1301		final CFException ex = new CFException();
1302		final CompletableFuture<Integer> f = new CompletableFuture<>();
1303	<	final Noop r = new Noop(m);
1304	<	if (!createIncomplete) f.completeExceptionally(ex);
1296	<	final CompletableFuture<Void> g = m.thenRun(f, r);
1297	<	if (createIncomplete) {
1298	<	checkIncomplete(g);
1299	<	f.completeExceptionally(ex);
1300	<	}
1303	>	final Noop[] rs = new Noop[6];
1304	>	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1305
1306	<	checkCompletedWithWrappedException(g, ex);
1306	>	final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1307	>	final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1308	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1309	>	checkIncomplete(h0);
1310	>	checkIncomplete(h1);
1311	>	checkIncomplete(h2);
1312	>	assertTrue(f.completeExceptionally(ex));
1313	>	final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1314	>	final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1315	>	final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1316	>
1317	>	checkCompletedWithWrappedException(h0, ex);
1318	>	checkCompletedWithWrappedException(h1, ex);
1319	>	checkCompletedWithWrappedException(h2, ex);
1320	>	checkCompletedWithWrappedException(h3, ex);
1321	>	checkCompletedWithWrappedException(h4, ex);
1322	>	checkCompletedWithWrappedException(h5, ex);
1323		checkCompletedExceptionally(f, ex);
1324	<	r.assertNotInvoked();
1324	>	for (Noop r : rs) r.assertNotInvoked();
1325		}}
1326
1327		/**
#	Line 1309 | Line 1329 | public class CompletableFutureTest exten
1329		*/
1330		public void testThenRun_sourceCancelled() {
1331		for (ExecutionMode m : ExecutionMode.values())
1312	–	for (boolean createIncomplete : new boolean[] { true, false })
1332		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1333		{
1334		final CompletableFuture<Integer> f = new CompletableFuture<>();
1335	<	final Noop r = new Noop(m);
1336	<	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1318	<	final CompletableFuture<Void> g = m.thenRun(f, r);
1319	<	if (createIncomplete) {
1320	<	checkIncomplete(g);
1321	<	assertTrue(f.cancel(mayInterruptIfRunning));
1322	<	}
1335	>	final Noop[] rs = new Noop[6];
1336	>	for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
1337
1338	<	checkCompletedWithWrappedCancellationException(g);
1338	>	final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1339	>	final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1340	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1341	>	checkIncomplete(h0);
1342	>	checkIncomplete(h1);
1343	>	checkIncomplete(h2);
1344	>	assertTrue(f.cancel(mayInterruptIfRunning));
1345	>	final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1346	>	final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1347	>	final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1348	>
1349	>	checkCompletedWithWrappedCancellationException(h0);
1350	>	checkCompletedWithWrappedCancellationException(h1);
1351	>	checkCompletedWithWrappedCancellationException(h2);
1352	>	checkCompletedWithWrappedCancellationException(h3);
1353	>	checkCompletedWithWrappedCancellationException(h4);
1354	>	checkCompletedWithWrappedCancellationException(h5);
1355		checkCancelled(f);
1356	<	r.assertNotInvoked();
1356	>	for (Noop r : rs) r.assertNotInvoked();
1357		}}
1358
1359		/**
#	Line 1331 | Line 1361 | public class CompletableFutureTest exten
1361		*/
1362		public void testThenRun_actionFailed() {
1363		for (ExecutionMode m : ExecutionMode.values())
1334	–	for (boolean createIncomplete : new boolean[] { true, false })
1364		for (Integer v1 : new Integer[] { 1, null })
1365		{
1366		final CompletableFuture<Integer> f = new CompletableFuture<>();
1367	<	final FailingRunnable r = new FailingRunnable(m);
1368	<	if (!createIncomplete) assertTrue(f.complete(v1));
1340	<	final CompletableFuture<Void> g = m.thenRun(f, r);
1341	<	if (createIncomplete) {
1342	<	checkIncomplete(g);
1343	<	assertTrue(f.complete(v1));
1344	<	}
1367	>	final FailingRunnable[] rs = new FailingRunnable[6];
1368	>	for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
1369
1370	<	checkCompletedWithWrappedCFException(g);
1370	>	final CompletableFuture<Void> h0 = m.thenRun(f, rs[0]);
1371	>	final CompletableFuture<Void> h1 = m.runAfterBoth(f, f, rs[1]);
1372	>	final CompletableFuture<Void> h2 = m.runAfterEither(f, f, rs[2]);
1373	>	assertTrue(f.complete(v1));
1374	>	final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1375	>	final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1376	>	final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1377	>
1378	>	checkCompletedWithWrappedCFException(h0);
1379	>	checkCompletedWithWrappedCFException(h1);
1380	>	checkCompletedWithWrappedCFException(h2);
1381	>	checkCompletedWithWrappedCFException(h3);
1382	>	checkCompletedWithWrappedCFException(h4);
1383	>	checkCompletedWithWrappedCFException(h5);
1384		checkCompletedNormally(f, v1);
1385		}}
1386
#	Line 1352 | Line 1389 | public class CompletableFutureTest exten
1389		*/
1390		public void testThenApply_normalCompletion() {
1391		for (ExecutionMode m : ExecutionMode.values())
1355	–	for (boolean createIncomplete : new boolean[] { true, false })
1392		for (Integer v1 : new Integer[] { 1, null })
1393		{
1394		final CompletableFuture<Integer> f = new CompletableFuture<>();
1395	<	final IncFunction r = new IncFunction(m);
1396	<	if (!createIncomplete) assertTrue(f.complete(v1));
1361	<	final CompletableFuture<Integer> g = m.thenApply(f, r);
1362	<	if (createIncomplete) {
1363	<	checkIncomplete(g);
1364	<	assertTrue(f.complete(v1));
1365	<	}
1395	>	final IncFunction[] rs = new IncFunction[4];
1396	>	for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1397
1398	<	checkCompletedNormally(g, inc(v1));
1398	>	final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1399	>	final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1400	>	checkIncomplete(h0);
1401	>	checkIncomplete(h1);
1402	>	assertTrue(f.complete(v1));
1403	>	final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1404	>	final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1405	>
1406	>	checkCompletedNormally(h0, inc(v1));
1407	>	checkCompletedNormally(h1, inc(v1));
1408	>	checkCompletedNormally(h2, inc(v1));
1409	>	checkCompletedNormally(h3, inc(v1));
1410		checkCompletedNormally(f, v1);
1411	<	r.assertValue(inc(v1));
1411	>	for (IncFunction r : rs) r.assertValue(inc(v1));
1412		}}
1413
1414		/**
#	Line 1375 | Line 1417 | public class CompletableFutureTest exten
1417		*/
1418		public void testThenApply_exceptionalCompletion() {
1419		for (ExecutionMode m : ExecutionMode.values())
1378	–	for (boolean createIncomplete : new boolean[] { true, false })
1420		{
1421		final CFException ex = new CFException();
1422		final CompletableFuture<Integer> f = new CompletableFuture<>();
1423	<	final IncFunction r = new IncFunction(m);
1424	<	if (!createIncomplete) f.completeExceptionally(ex);
1384	<	final CompletableFuture<Integer> g = m.thenApply(f, r);
1385	<	if (createIncomplete) {
1386	<	checkIncomplete(g);
1387	<	f.completeExceptionally(ex);
1388	<	}
1423	>	final IncFunction[] rs = new IncFunction[4];
1424	>	for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1425
1426	<	checkCompletedWithWrappedException(g, ex);
1426	>	final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1427	>	final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1428	>	assertTrue(f.completeExceptionally(ex));
1429	>	final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1430	>	final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1431	>
1432	>	checkCompletedWithWrappedException(h0, ex);
1433	>	checkCompletedWithWrappedException(h1, ex);
1434	>	checkCompletedWithWrappedException(h2, ex);
1435	>	checkCompletedWithWrappedException(h3, ex);
1436		checkCompletedExceptionally(f, ex);
1437	<	r.assertNotInvoked();
1437	>	for (IncFunction r : rs) r.assertNotInvoked();
1438		}}
1439
1440		/**
#	Line 1397 | Line 1442 | public class CompletableFutureTest exten
1442		*/
1443		public void testThenApply_sourceCancelled() {
1444		for (ExecutionMode m : ExecutionMode.values())
1400	–	for (boolean createIncomplete : new boolean[] { true, false })
1445		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1446		{
1447		final CompletableFuture<Integer> f = new CompletableFuture<>();
1448	<	final IncFunction r = new IncFunction(m);
1449	<	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1406	<	final CompletableFuture<Integer> g = m.thenApply(f, r);
1407	<	if (createIncomplete) {
1408	<	checkIncomplete(g);
1409	<	assertTrue(f.cancel(mayInterruptIfRunning));
1410	<	}
1448	>	final IncFunction[] rs = new IncFunction[4];
1449	>	for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1450
1451	<	checkCompletedWithWrappedCancellationException(g);
1451	>	final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1452	>	final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1453	>	assertTrue(f.cancel(mayInterruptIfRunning));
1454	>	final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1455	>	final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1456	>
1457	>	checkCompletedWithWrappedCancellationException(h0);
1458	>	checkCompletedWithWrappedCancellationException(h1);
1459	>	checkCompletedWithWrappedCancellationException(h2);
1460	>	checkCompletedWithWrappedCancellationException(h3);
1461		checkCancelled(f);
1462	<	r.assertNotInvoked();
1462	>	for (IncFunction r : rs) r.assertNotInvoked();
1463		}}
1464
1465		/**
#	Line 1419 | Line 1467 | public class CompletableFutureTest exten
1467		*/
1468		public void testThenApply_actionFailed() {
1469		for (ExecutionMode m : ExecutionMode.values())
1422	–	for (boolean createIncomplete : new boolean[] { true, false })
1470		for (Integer v1 : new Integer[] { 1, null })
1471		{
1472		final CompletableFuture<Integer> f = new CompletableFuture<>();
1473	<	final FailingFunction r = new FailingFunction(m);
1474	<	if (!createIncomplete) assertTrue(f.complete(v1));
1428	<	final CompletableFuture<Integer> g = m.thenApply(f, r);
1429	<	if (createIncomplete) {
1430	<	checkIncomplete(g);
1431	<	assertTrue(f.complete(v1));
1432	<	}
1473	>	final FailingFunction[] rs = new FailingFunction[4];
1474	>	for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1475
1476	<	checkCompletedWithWrappedCFException(g);
1476	>	final CompletableFuture<Integer> h0 = m.thenApply(f, rs[0]);
1477	>	final CompletableFuture<Integer> h1 = m.applyToEither(f, f, rs[1]);
1478	>	assertTrue(f.complete(v1));
1479	>	final CompletableFuture<Integer> h2 = m.thenApply(f, rs[2]);
1480	>	final CompletableFuture<Integer> h3 = m.applyToEither(f, f, rs[3]);
1481	>
1482	>	checkCompletedWithWrappedCFException(h0);
1483	>	checkCompletedWithWrappedCFException(h1);
1484	>	checkCompletedWithWrappedCFException(h2);
1485	>	checkCompletedWithWrappedCFException(h3);
1486		checkCompletedNormally(f, v1);
1487		}}
1488
#	Line 1440 | Line 1491 | public class CompletableFutureTest exten
1491		*/
1492		public void testThenAccept_normalCompletion() {
1493		for (ExecutionMode m : ExecutionMode.values())
1443	–	for (boolean createIncomplete : new boolean[] { true, false })
1494		for (Integer v1 : new Integer[] { 1, null })
1495		{
1496		final CompletableFuture<Integer> f = new CompletableFuture<>();
1497	<	final NoopConsumer r = new NoopConsumer(m);
1498	<	if (!createIncomplete) assertTrue(f.complete(v1));
1449	<	final CompletableFuture<Void> g = m.thenAccept(f, r);
1450	<	if (createIncomplete) {
1451	<	checkIncomplete(g);
1452	<	assertTrue(f.complete(v1));
1453	<	}
1497	>	final NoopConsumer[] rs = new NoopConsumer[4];
1498	>	for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1499
1500	<	checkCompletedNormally(g, null);
1501	<	r.assertValue(v1);
1500	>	final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1501	>	final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1502	>	checkIncomplete(h0);
1503	>	checkIncomplete(h1);
1504	>	assertTrue(f.complete(v1));
1505	>	final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1506	>	final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1507	>
1508	>	checkCompletedNormally(h0, null);
1509	>	checkCompletedNormally(h1, null);
1510	>	checkCompletedNormally(h2, null);
1511	>	checkCompletedNormally(h3, null);
1512		checkCompletedNormally(f, v1);
1513	+	for (NoopConsumer r : rs) r.assertValue(v1);
1514		}}
1515
1516		/**
#	Line 1463 | Line 1519 | public class CompletableFutureTest exten
1519		*/
1520		public void testThenAccept_exceptionalCompletion() {
1521		for (ExecutionMode m : ExecutionMode.values())
1466	–	for (boolean createIncomplete : new boolean[] { true, false })
1522		{
1523		final CFException ex = new CFException();
1524		final CompletableFuture<Integer> f = new CompletableFuture<>();
1525	<	final NoopConsumer r = new NoopConsumer(m);
1526	<	if (!createIncomplete) f.completeExceptionally(ex);
1472	<	final CompletableFuture<Void> g = m.thenAccept(f, r);
1473	<	if (createIncomplete) {
1474	<	checkIncomplete(g);
1475	<	f.completeExceptionally(ex);
1476	<	}
1525	>	final NoopConsumer[] rs = new NoopConsumer[4];
1526	>	for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1527
1528	<	checkCompletedWithWrappedException(g, ex);
1528	>	final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1529	>	final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1530	>	assertTrue(f.completeExceptionally(ex));
1531	>	final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1532	>	final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1533	>
1534	>	checkCompletedWithWrappedException(h0, ex);
1535	>	checkCompletedWithWrappedException(h1, ex);
1536	>	checkCompletedWithWrappedException(h2, ex);
1537	>	checkCompletedWithWrappedException(h3, ex);
1538		checkCompletedExceptionally(f, ex);
1539	<	r.assertNotInvoked();
1539	>	for (NoopConsumer r : rs) r.assertNotInvoked();
1540		}}
1541
1542		/**
#	Line 1485 | Line 1544 | public class CompletableFutureTest exten
1544		*/
1545		public void testThenAccept_sourceCancelled() {
1546		for (ExecutionMode m : ExecutionMode.values())
1488	–	for (boolean createIncomplete : new boolean[] { true, false })
1547		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1548		{
1549		final CompletableFuture<Integer> f = new CompletableFuture<>();
1550	<	final NoopConsumer r = new NoopConsumer(m);
1551	<	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1494	<	final CompletableFuture<Void> g = m.thenAccept(f, r);
1495	<	if (createIncomplete) {
1496	<	checkIncomplete(g);
1497	<	assertTrue(f.cancel(mayInterruptIfRunning));
1498	<	}
1550	>	final NoopConsumer[] rs = new NoopConsumer[4];
1551	>	for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
1552
1553	<	checkCompletedWithWrappedCancellationException(g);
1553	>	final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1554	>	final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1555	>	assertTrue(f.cancel(mayInterruptIfRunning));
1556	>	final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1557	>	final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1558	>
1559	>	checkCompletedWithWrappedCancellationException(h0);
1560	>	checkCompletedWithWrappedCancellationException(h1);
1561	>	checkCompletedWithWrappedCancellationException(h2);
1562	>	checkCompletedWithWrappedCancellationException(h3);
1563		checkCancelled(f);
1564	<	r.assertNotInvoked();
1564	>	for (NoopConsumer r : rs) r.assertNotInvoked();
1565		}}
1566
1567		/**
#	Line 1507 | Line 1569 | public class CompletableFutureTest exten
1569		*/
1570		public void testThenAccept_actionFailed() {
1571		for (ExecutionMode m : ExecutionMode.values())
1510	–	for (boolean createIncomplete : new boolean[] { true, false })
1572		for (Integer v1 : new Integer[] { 1, null })
1573		{
1574		final CompletableFuture<Integer> f = new CompletableFuture<>();
1575	<	final FailingConsumer r = new FailingConsumer(m);
1576	<	if (!createIncomplete) f.complete(v1);
1516	<	final CompletableFuture<Void> g = m.thenAccept(f, r);
1517	<	if (createIncomplete) {
1518	<	checkIncomplete(g);
1519	<	f.complete(v1);
1520	<	}
1575	>	final FailingConsumer[] rs = new FailingConsumer[4];
1576	>	for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
1577
1578	<	checkCompletedWithWrappedCFException(g);
1578	>	final CompletableFuture<Void> h0 = m.thenAccept(f, rs[0]);
1579	>	final CompletableFuture<Void> h1 = m.acceptEither(f, f, rs[1]);
1580	>	assertTrue(f.complete(v1));
1581	>	final CompletableFuture<Void> h2 = m.thenAccept(f, rs[2]);
1582	>	final CompletableFuture<Void> h3 = m.acceptEither(f, f, rs[3]);
1583	>
1584	>	checkCompletedWithWrappedCFException(h0);
1585	>	checkCompletedWithWrappedCFException(h1);
1586	>	checkCompletedWithWrappedCFException(h2);
1587	>	checkCompletedWithWrappedCFException(h3);
1588		checkCompletedNormally(f, v1);
1589		}}
1590
#	Line 1535 | Line 1600 | public class CompletableFutureTest exten
1600		{
1601		final CompletableFuture<Integer> f = new CompletableFuture<>();
1602		final CompletableFuture<Integer> g = new CompletableFuture<>();
1603	<	final SubtractFunction r1 = new SubtractFunction(m);
1604	<	final SubtractFunction r2 = new SubtractFunction(m);
1540	<	final SubtractFunction r3 = new SubtractFunction(m);
1603	>	final SubtractFunction[] rs = new SubtractFunction[6];
1604	>	for (int i = 0; i < rs.length; i++) rs[i] = new SubtractFunction(m);
1605
1606		final CompletableFuture<Integer> fst =  fFirst ? f : g;
1607		final CompletableFuture<Integer> snd = !fFirst ? f : g;
1608		final Integer w1 =  fFirst ? v1 : v2;
1609		final Integer w2 = !fFirst ? v1 : v2;
1610
1611	<	final CompletableFuture<Integer> h1 = m.thenCombine(f, g, r1);
1611	>	final CompletableFuture<Integer> h0 = m.thenCombine(f, g, rs[0]);
1612	>	final CompletableFuture<Integer> h1 = m.thenCombine(fst, fst, rs[1]);
1613		assertTrue(fst.complete(w1));
1614	<	final CompletableFuture<Integer> h2 = m.thenCombine(f, g, r2);
1615	<	checkIncomplete(h1);
1616	<	checkIncomplete(h2);
1617	<	r1.assertNotInvoked();
1618	<	r2.assertNotInvoked();
1614	>	final CompletableFuture<Integer> h2 = m.thenCombine(f, g, rs[2]);
1615	>	final CompletableFuture<Integer> h3 = m.thenCombine(fst, fst, rs[3]);
1616	>	checkIncomplete(h0); rs[0].assertNotInvoked();
1617	>	checkIncomplete(h2); rs[2].assertNotInvoked();
1618	>	checkCompletedNormally(h1, subtract(w1, w1));
1619	>	checkCompletedNormally(h3, subtract(w1, w1));
1620	>	rs[1].assertValue(subtract(w1, w1));
1621	>	rs[3].assertValue(subtract(w1, w1));
1622		assertTrue(snd.complete(w2));
1623	<	final CompletableFuture<Integer> h3 = m.thenCombine(f, g, r3);
1623	>	final CompletableFuture<Integer> h4 = m.thenCombine(f, g, rs[4]);
1624
1625	<	checkCompletedNormally(h1, subtract(v1, v2));
1625	>	checkCompletedNormally(h0, subtract(v1, v2));
1626		checkCompletedNormally(h2, subtract(v1, v2));
1627	<	checkCompletedNormally(h3, subtract(v1, v2));
1628	<	r1.assertValue(subtract(v1, v2));
1629	<	r2.assertValue(subtract(v1, v2));
1630	<	r3.assertValue(subtract(v1, v2));
1627	>	checkCompletedNormally(h4, subtract(v1, v2));
1628	>	rs[0].assertValue(subtract(v1, v2));
1629	>	rs[2].assertValue(subtract(v1, v2));
1630	>	rs[4].assertValue(subtract(v1, v2));
1631	>
1632		checkCompletedNormally(f, v1);
1633		checkCompletedNormally(g, v2);
1634		}}
#	Line 2922 | Line 2991 | public class CompletableFutureTest exten
2991		* when all components complete normally
2992		*/
2993		public void testAllOf_normal() throws Exception {
2994	<	for (int k = 1; k < 20; ++k) {
2994	>	for (int k = 1; k < 10; k++) {
2995		CompletableFuture<Integer>[] fs
2996		= (CompletableFuture<Integer>[]) new CompletableFuture[k];
2997	<	for (int i = 0; i < k; ++i)
2997	>	for (int i = 0; i < k; i++)
2998		fs[i] = new CompletableFuture<>();
2999		CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3000	<	for (int i = 0; i < k; ++i) {
3000	>	for (int i = 0; i < k; i++) {
3001		checkIncomplete(f);
3002		checkIncomplete(CompletableFuture.allOf(fs));
3003		fs[i].complete(one);
#	Line 2939 | Line 3008 | public class CompletableFutureTest exten
3008		}
3009
3010		public void testAllOf_backwards() throws Exception {
3011	<	for (int k = 1; k < 20; ++k) {
3011	>	for (int k = 1; k < 10; k++) {
3012		CompletableFuture<Integer>[] fs
3013		= (CompletableFuture<Integer>[]) new CompletableFuture[k];
3014	<	for (int i = 0; i < k; ++i)
3014	>	for (int i = 0; i < k; i++)
3015		fs[i] = new CompletableFuture<>();
3016		CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3017		for (int i = k - 1; i >= 0; i--) {
#	Line 2955 | Line 3024 | public class CompletableFutureTest exten
3024		}
3025		}
3026
3027	+	public void testAllOf_exceptional() throws Exception {
3028	+	for (int k = 1; k < 10; k++) {
3029	+	CompletableFuture<Integer>[] fs
3030	+	= (CompletableFuture<Integer>[]) new CompletableFuture[k];
3031	+	CFException ex = new CFException();
3032	+	for (int i = 0; i < k; i++)
3033	+	fs[i] = new CompletableFuture<>();
3034	+	CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3035	+	for (int i = 0; i < k; i++) {
3036	+	checkIncomplete(f);
3037	+	checkIncomplete(CompletableFuture.allOf(fs));
3038	+	if (i != k/2) {
3039	+	fs[i].complete(i);
3040	+	checkCompletedNormally(fs[i], i);
3041	+	} else {
3042	+	fs[i].completeExceptionally(ex);
3043	+	checkCompletedExceptionally(fs[i], ex);
3044	+	}
3045	+	}
3046	+	checkCompletedWithWrappedException(f, ex);
3047	+	checkCompletedWithWrappedException(CompletableFuture.allOf(fs), ex);
3048	+	}
3049	+	}
3050	+
3051		/**
3052		* anyOf(no component futures) returns an incomplete future
3053		*/
3054		public void testAnyOf_empty() throws Exception {
3055	+	for (Integer v1 : new Integer[] { 1, null })
3056	+	{
3057		CompletableFuture<Object> f = CompletableFuture.anyOf();
3058		checkIncomplete(f);
3059	<	}
3059	>
3060	>	f.complete(v1);
3061	>	checkCompletedNormally(f, v1);
3062	>	}}
3063
3064		/**
3065		* anyOf returns a future completed normally with a value when
3066		* a component future does
3067		*/
3068		public void testAnyOf_normal() throws Exception {
3069	<	for (int k = 0; k < 10; ++k) {
3069	>	for (int k = 0; k < 10; k++) {
3070		CompletableFuture[] fs = new CompletableFuture[k];
3071	<	for (int i = 0; i < k; ++i)
3071	>	for (int i = 0; i < k; i++)
3072		fs[i] = new CompletableFuture<>();
3073		CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3074		checkIncomplete(f);
3075	<	for (int i = 0; i < k; ++i) {
3076	<	fs[i].complete(one);
3077	<	checkCompletedNormally(f, one);
3078	<	checkCompletedNormally(CompletableFuture.anyOf(fs), one);
3075	>	for (int i = 0; i < k; i++) {
3076	>	fs[i].complete(i);
3077	>	checkCompletedNormally(f, 0);
3078	>	int x = (int) CompletableFuture.anyOf(fs).join();
3079	>	assertTrue(0 <= x && x <= i);
3080	>	}
3081	>	}
3082	>	}
3083	>	public void testAnyOf_normal_backwards() throws Exception {
3084	>	for (int k = 0; k < 10; k++) {
3085	>	CompletableFuture[] fs = new CompletableFuture[k];
3086	>	for (int i = 0; i < k; i++)
3087	>	fs[i] = new CompletableFuture<>();
3088	>	CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3089	>	checkIncomplete(f);
3090	>	for (int i = k - 1; i >= 0; i--) {
3091	>	fs[i].complete(i);
3092	>	checkCompletedNormally(f, k - 1);
3093	>	int x = (int) CompletableFuture.anyOf(fs).join();
3094	>	assertTrue(i <= x && x <= k - 1);
3095		}
3096		}
3097		}
#	Line 2986 | Line 3100 | public class CompletableFutureTest exten
3100		* anyOf result completes exceptionally when any component does.
3101		*/
3102		public void testAnyOf_exceptional() throws Exception {
3103	<	for (int k = 0; k < 10; ++k) {
3103	>	for (int k = 0; k < 10; k++) {
3104		CompletableFuture[] fs = new CompletableFuture[k];
3105	<	for (int i = 0; i < k; ++i)
3105	>	CFException[] exs = new CFException[k];
3106	>	for (int i = 0; i < k; i++) {
3107		fs[i] = new CompletableFuture<>();
3108	+	exs[i] = new CFException();
3109	+	}
3110		CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3111		checkIncomplete(f);
3112	<	for (int i = 0; i < k; ++i) {
3113	<	fs[i].completeExceptionally(new CFException());
3114	<	checkCompletedWithWrappedCFException(f);
3112	>	for (int i = 0; i < k; i++) {
3113	>	fs[i].completeExceptionally(exs[i]);
3114	>	checkCompletedWithWrappedException(f, exs[0]);
3115	>	checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3116	>	}
3117	>	}
3118	>	}
3119	>
3120	>	public void testAnyOf_exceptional_backwards() throws Exception {
3121	>	for (int k = 0; k < 10; k++) {
3122	>	CompletableFuture[] fs = new CompletableFuture[k];
3123	>	CFException[] exs = new CFException[k];
3124	>	for (int i = 0; i < k; i++) {
3125	>	fs[i] = new CompletableFuture<>();
3126	>	exs[i] = new CFException();
3127	>	}
3128	>	CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3129	>	checkIncomplete(f);
3130	>	for (int i = k - 1; i >= 0; i--) {
3131	>	fs[i].completeExceptionally(exs[i]);
3132	>	checkCompletedWithWrappedException(f, exs[k - 1]);
3133		checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3134		}
3135		}
#	Line 3118 | Line 3253 | public class CompletableFutureTest exten
3253		assertSame(f, f.toCompletableFuture());
3254		}
3255
3256	<	//     public void testRunAfterEither_resultDeterminedAtTimeOfCreation() {
3257	<	//         for (ExecutionMode m : ExecutionMode.values())
3258	<	//         for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3259	<	//         for (Integer v1 : new Integer[] { 1, null })
3260	<	//     {
3261	<	//         final CompletableFuture<Integer> f = new CompletableFuture<>();
3262	<	//         final CompletableFuture<Integer> g = new CompletableFuture<>();
3263	<	//         final Noop[] rs = new Noop[2];
3264	<	//         for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
3265	<	//         f.complete(v1);
3266	<	//         final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
3267	<	//         final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
3268	<	//         assertTrue(g.cancel(mayInterruptIfRunning));
3269	<	//         checkCompletedNormally(h0, null);
3270	<	//         checkCompletedNormally(h1, null);
3271	<	//         for (Noop r : rs) r.assertInvoked();
3272	<	//     }}
3256	>	//--- tests of implementation details; not part of official tck ---
3257	>
3258	>	Object resultOf(CompletableFuture<?> f) {
3259	>	try {
3260	>	java.lang.reflect.Field resultField
3261	>	= CompletableFuture.class.getDeclaredField("result");
3262	>	resultField.setAccessible(true);
3263	>	return resultField.get(f);
3264	>	} catch (Throwable t) { throw new AssertionError(t); }
3265	>	}
3266	>
3267	>	public void testExceptionPropagationReusesResultObject() {
3268	>	if (!testImplementationDetails) return;
3269	>	for (ExecutionMode m : ExecutionMode.values())
3270	>	{
3271	>	final CFException ex = new CFException();
3272	>	final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3273	>	final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3274	>
3275	>	List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3276	>	= new ArrayList<>();
3277	>
3278	>	funs.add((y) -> m.thenRun(y, new Noop(m)));
3279	>	funs.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3280	>	funs.add((y) -> m.thenApply(y, new IncFunction(m)));
3281	>
3282	>	funs.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3283	>	funs.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3284	>	funs.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3285	>
3286	>	funs.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3287	>	funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3288	>	funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3289	>
3290	>	funs.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3291	>
3292	>	funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3293	>
3294	>	funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
3295	>	funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
3296	>
3297	>	for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3298	>	fun : funs) {
3299	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3300	>	f.completeExceptionally(ex);
3301	>	CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3302	>	checkCompletedWithWrappedException(src, ex);
3303	>	CompletableFuture<?> dep = fun.apply(src);
3304	>	checkCompletedWithWrappedException(dep, ex);
3305	>	assertSame(resultOf(src), resultOf(dep));
3306	>	}
3307	>
3308	>	for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3309	>	fun : funs) {
3310	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3311	>	CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3312	>	CompletableFuture<?> dep = fun.apply(src);
3313	>	f.completeExceptionally(ex);
3314	>	checkCompletedWithWrappedException(src, ex);
3315	>	checkCompletedWithWrappedException(dep, ex);
3316	>	assertSame(resultOf(src), resultOf(dep));
3317	>	}
3318	>
3319	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3320	>	for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3321	>	fun : funs) {
3322	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3323	>	f.cancel(mayInterruptIfRunning);
3324	>	checkCancelled(f);
3325	>	CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3326	>	checkCompletedWithWrappedCancellationException(src);
3327	>	CompletableFuture<?> dep = fun.apply(src);
3328	>	checkCompletedWithWrappedCancellationException(dep);
3329	>	assertSame(resultOf(src), resultOf(dep));
3330	>	}
3331	>
3332	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3333	>	for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3334	>	fun : funs) {
3335	>	CompletableFuture<Integer> f = new CompletableFuture<>();
3336	>	CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3337	>	CompletableFuture<?> dep = fun.apply(src);
3338	>	f.cancel(mayInterruptIfRunning);
3339	>	checkCancelled(f);
3340	>	checkCompletedWithWrappedCancellationException(src);
3341	>	checkCompletedWithWrappedCancellationException(dep);
3342	>	assertSame(resultOf(src), resultOf(dep));
3343	>	}
3344	>	}}
3345
3346		}

Diff Legend

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