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.83 by jsr166, Mon Jun 16 20:16:32 2014 UTC vs.
Revision 1.91 by jsr166, Tue Jun 17 20:34:18 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 2922 | Line 2973 | public class CompletableFutureTest exten
2973       * when all components complete normally
2974       */
2975      public void testAllOf_normal() throws Exception {
2976 <        for (int k = 1; k < 20; ++k) {
2976 >        for (int k = 1; k < 10; k++) {
2977              CompletableFuture<Integer>[] fs
2978                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2979 <            for (int i = 0; i < k; ++i)
2979 >            for (int i = 0; i < k; i++)
2980                  fs[i] = new CompletableFuture<>();
2981              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2982 <            for (int i = 0; i < k; ++i) {
2982 >            for (int i = 0; i < k; i++) {
2983                  checkIncomplete(f);
2984                  checkIncomplete(CompletableFuture.allOf(fs));
2985                  fs[i].complete(one);
# Line 2939 | Line 2990 | public class CompletableFutureTest exten
2990      }
2991  
2992      public void testAllOf_backwards() throws Exception {
2993 <        for (int k = 1; k < 20; ++k) {
2993 >        for (int k = 1; k < 10; k++) {
2994              CompletableFuture<Integer>[] fs
2995                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2996 <            for (int i = 0; i < k; ++i)
2996 >            for (int i = 0; i < k; i++)
2997                  fs[i] = new CompletableFuture<>();
2998              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2999              for (int i = k - 1; i >= 0; i--) {
# Line 2955 | Line 3006 | public class CompletableFutureTest exten
3006          }
3007      }
3008  
3009 +    public void testAllOf_exceptional() throws Exception {
3010 +        for (int k = 1; k < 10; k++) {
3011 +            CompletableFuture<Integer>[] fs
3012 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3013 +            CFException ex = new CFException();
3014 +            for (int i = 0; i < k; i++)
3015 +                fs[i] = new CompletableFuture<>();
3016 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3017 +            for (int i = 0; i < k; i++) {
3018 +                checkIncomplete(f);
3019 +                checkIncomplete(CompletableFuture.allOf(fs));
3020 +                if (i != k/2) {
3021 +                    fs[i].complete(i);
3022 +                    checkCompletedNormally(fs[i], i);
3023 +                } else {
3024 +                    fs[i].completeExceptionally(ex);
3025 +                    checkCompletedExceptionally(fs[i], ex);
3026 +                }
3027 +            }
3028 +            checkCompletedWithWrappedException(f, ex);
3029 +            checkCompletedWithWrappedException(CompletableFuture.allOf(fs), ex);
3030 +        }
3031 +    }
3032 +
3033      /**
3034       * anyOf(no component futures) returns an incomplete future
3035       */
3036      public void testAnyOf_empty() throws Exception {
3037 +        for (Integer v1 : new Integer[] { 1, null })
3038 +    {
3039          CompletableFuture<Object> f = CompletableFuture.anyOf();
3040          checkIncomplete(f);
3041 <    }
3041 >
3042 >        f.complete(v1);
3043 >        checkCompletedNormally(f, v1);
3044 >    }}
3045  
3046      /**
3047       * anyOf returns a future completed normally with a value when
3048       * a component future does
3049       */
3050      public void testAnyOf_normal() throws Exception {
3051 <        for (int k = 0; k < 10; ++k) {
3051 >        for (int k = 0; k < 10; k++) {
3052              CompletableFuture[] fs = new CompletableFuture[k];
3053 <            for (int i = 0; i < k; ++i)
3053 >            for (int i = 0; i < k; i++)
3054                  fs[i] = new CompletableFuture<>();
3055              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3056              checkIncomplete(f);
3057 <            for (int i = 0; i < k; ++i) {
3058 <                fs[i].complete(one);
3059 <                checkCompletedNormally(f, one);
3060 <                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
3057 >            for (int i = 0; i < k; i++) {
3058 >                fs[i].complete(i);
3059 >                checkCompletedNormally(f, 0);
3060 >                int x = (int) CompletableFuture.anyOf(fs).join();
3061 >                assertTrue(0 <= x && x <= i);
3062 >            }
3063 >        }
3064 >    }
3065 >    public void testAnyOf_normal_backwards() throws Exception {
3066 >        for (int k = 0; k < 10; k++) {
3067 >            CompletableFuture[] fs = new CompletableFuture[k];
3068 >            for (int i = 0; i < k; i++)
3069 >                fs[i] = new CompletableFuture<>();
3070 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3071 >            checkIncomplete(f);
3072 >            for (int i = k - 1; i >= 0; i--) {
3073 >                fs[i].complete(i);
3074 >                checkCompletedNormally(f, k - 1);
3075 >                int x = (int) CompletableFuture.anyOf(fs).join();
3076 >                assertTrue(i <= x && x <= k - 1);
3077              }
3078          }
3079      }
# Line 2986 | Line 3082 | public class CompletableFutureTest exten
3082       * anyOf result completes exceptionally when any component does.
3083       */
3084      public void testAnyOf_exceptional() throws Exception {
3085 <        for (int k = 0; k < 10; ++k) {
3085 >        for (int k = 0; k < 10; k++) {
3086              CompletableFuture[] fs = new CompletableFuture[k];
3087 <            for (int i = 0; i < k; ++i)
3087 >            CFException[] exs = new CFException[k];
3088 >            for (int i = 0; i < k; i++) {
3089                  fs[i] = new CompletableFuture<>();
3090 +                exs[i] = new CFException();
3091 +            }
3092              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3093              checkIncomplete(f);
3094 <            for (int i = 0; i < k; ++i) {
3095 <                fs[i].completeExceptionally(new CFException());
3096 <                checkCompletedWithWrappedCFException(f);
3094 >            for (int i = 0; i < k; i++) {
3095 >                fs[i].completeExceptionally(exs[i]);
3096 >                checkCompletedWithWrappedException(f, exs[0]);
3097 >                checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3098 >            }
3099 >        }
3100 >    }
3101 >
3102 >    public void testAnyOf_exceptional_backwards() throws Exception {
3103 >        for (int k = 0; k < 10; k++) {
3104 >            CompletableFuture[] fs = new CompletableFuture[k];
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 = k - 1; i >= 0; i--) {
3113 >                fs[i].completeExceptionally(exs[i]);
3114 >                checkCompletedWithWrappedException(f, exs[k - 1]);
3115                  checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3116              }
3117          }
# Line 3137 | Line 3254 | public class CompletableFutureTest exten
3254          final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3255          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3256  
3257 <        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> dependentFactories
3257 >        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3258              = new ArrayList<>();
3259  
3260 <        dependentFactories.add((y) -> m.thenRun(y, new Noop(m)));
3261 <        dependentFactories.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3262 <        dependentFactories.add((y) -> m.thenApply(y, new IncFunction(m)));
3260 >        funs.add((y) -> m.thenRun(y, new Noop(m)));
3261 >        funs.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3262 >        funs.add((y) -> m.thenApply(y, new IncFunction(m)));
3263  
3264 <        dependentFactories.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3265 <        dependentFactories.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3266 <        dependentFactories.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3264 >        funs.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3265 >        funs.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3266 >        funs.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3267  
3268 <        dependentFactories.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3269 <        dependentFactories.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3270 <        dependentFactories.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3268 >        funs.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3269 >        funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3270 >        funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3271  
3272 <        dependentFactories.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3272 >        funs.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3273  
3274 <        dependentFactories.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3274 >        funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3275 >
3276 >        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
3277 >        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
3278  
3279          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3280 <                 dependentFactory : dependentFactories) {
3280 >                 fun : funs) {
3281              CompletableFuture<Integer> f = new CompletableFuture<>();
3282              f.completeExceptionally(ex);
3283              CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3284              checkCompletedWithWrappedException(src, ex);
3285 <            CompletableFuture<?> dep = dependentFactory.apply(src);
3285 >            CompletableFuture<?> dep = fun.apply(src);
3286              checkCompletedWithWrappedException(dep, ex);
3287              assertSame(resultOf(src), resultOf(dep));
3288          }
3289  
3290          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3291 <                 dependentFactory : dependentFactories) {
3291 >                 fun : funs) {
3292              CompletableFuture<Integer> f = new CompletableFuture<>();
3293              CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3294 <            CompletableFuture<?> dep = dependentFactory.apply(src);
3294 >            CompletableFuture<?> dep = fun.apply(src);
3295              f.completeExceptionally(ex);
3296              checkCompletedWithWrappedException(src, ex);
3297              checkCompletedWithWrappedException(dep, ex);
# Line 3180 | Line 3300 | public class CompletableFutureTest exten
3300  
3301          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3302          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3303 <                 dependentFactory : dependentFactories) {
3303 >                 fun : funs) {
3304              CompletableFuture<Integer> f = new CompletableFuture<>();
3305              f.cancel(mayInterruptIfRunning);
3306              checkCancelled(f);
3307              CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3308              checkCompletedWithWrappedCancellationException(src);
3309 <            CompletableFuture<?> dep = dependentFactory.apply(src);
3309 >            CompletableFuture<?> dep = fun.apply(src);
3310              checkCompletedWithWrappedCancellationException(dep);
3311              assertSame(resultOf(src), resultOf(dep));
3312          }
3313  
3314          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3315          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3316 <                 dependentFactory : dependentFactories) {
3316 >                 fun : funs) {
3317              CompletableFuture<Integer> f = new CompletableFuture<>();
3318              CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3319 <            CompletableFuture<?> dep = dependentFactory.apply(src);
3319 >            CompletableFuture<?> dep = fun.apply(src);
3320              f.cancel(mayInterruptIfRunning);
3321              checkCancelled(f);
3322              checkCompletedWithWrappedCancellationException(src);
# Line 3205 | Line 3325 | public class CompletableFutureTest exten
3325          }
3326      }}
3327  
3208 – //     public void testRunAfterEither_resultDeterminedAtTimeOfCreation() {
3209 – //         for (ExecutionMode m : ExecutionMode.values())
3210 – //         for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3211 – //         for (Integer v1 : new Integer[] { 1, null })
3212 – //     {
3213 – //         final CompletableFuture<Integer> f = new CompletableFuture<>();
3214 – //         final CompletableFuture<Integer> g = new CompletableFuture<>();
3215 – //         final Noop[] rs = new Noop[2];
3216 – //         for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
3217 – //         f.complete(v1);
3218 – //         final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
3219 – //         final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
3220 – //         assertTrue(g.cancel(mayInterruptIfRunning));
3221 – //         checkCompletedNormally(h0, null);
3222 – //         checkCompletedNormally(h1, null);
3223 – //         for (Noop r : rs) r.assertInvoked();
3224 – //     }}
3225 –
3328   }

Diff Legend

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