ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CompletableFutureTest.java
(Generate patch)

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.89 by jsr166, Mon Jun 16 21:34:49 2014 UTC vs.
Revision 1.94 by jsr166, Wed Jun 18 02:37:38 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      }}

Diff Legend

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