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.90 by jsr166, Tue Jun 17 18:09:28 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[] rs = new FailingRunnable[6];
1368 +        for (int i = 0; i < rs.length; i++) rs[i] = new FailingRunnable(m);
1369 +
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          final FailingRunnable r = new FailingRunnable(m);
1374 <        if (!createIncomplete) assertTrue(f.complete(v1));
1375 <        final CompletableFuture<Void> g = m.thenRun(f, r);
1376 <        if (createIncomplete) {
1377 <            checkIncomplete(g);
1343 <            assertTrue(f.complete(v1));
1344 <        }
1374 >        assertTrue(f.complete(v1));
1375 >        final CompletableFuture<Void> h3 = m.thenRun(f, rs[3]);
1376 >        final CompletableFuture<Void> h4 = m.runAfterBoth(f, f, rs[4]);
1377 >        final CompletableFuture<Void> h5 = m.runAfterEither(f, f, rs[5]);
1378  
1379 <        checkCompletedWithWrappedCFException(g);
1379 >        checkCompletedWithWrappedCFException(h0);
1380 >        checkCompletedWithWrappedCFException(h1);
1381 >        checkCompletedWithWrappedCFException(h2);
1382 >        checkCompletedWithWrappedCFException(h3);
1383 >        checkCompletedWithWrappedCFException(h4);
1384 >        checkCompletedWithWrappedCFException(h5);
1385          checkCompletedNormally(f, v1);
1386      }}
1387  
# Line 2922 | Line 2960 | public class CompletableFutureTest exten
2960       * when all components complete normally
2961       */
2962      public void testAllOf_normal() throws Exception {
2963 <        for (int k = 1; k < 20; ++k) {
2963 >        for (int k = 1; k < 10; k++) {
2964              CompletableFuture<Integer>[] fs
2965                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2966 <            for (int i = 0; i < k; ++i)
2966 >            for (int i = 0; i < k; i++)
2967                  fs[i] = new CompletableFuture<>();
2968              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2969 <            for (int i = 0; i < k; ++i) {
2969 >            for (int i = 0; i < k; i++) {
2970                  checkIncomplete(f);
2971                  checkIncomplete(CompletableFuture.allOf(fs));
2972                  fs[i].complete(one);
# Line 2939 | Line 2977 | public class CompletableFutureTest exten
2977      }
2978  
2979      public void testAllOf_backwards() throws Exception {
2980 <        for (int k = 1; k < 20; ++k) {
2980 >        for (int k = 1; k < 10; k++) {
2981              CompletableFuture<Integer>[] fs
2982                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2983 <            for (int i = 0; i < k; ++i)
2983 >            for (int i = 0; i < k; i++)
2984                  fs[i] = new CompletableFuture<>();
2985              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2986              for (int i = k - 1; i >= 0; i--) {
# Line 2955 | Line 2993 | public class CompletableFutureTest exten
2993          }
2994      }
2995  
2996 +    public void testAllOf_exceptional() throws Exception {
2997 +        for (int k = 1; k < 10; k++) {
2998 +            CompletableFuture<Integer>[] fs
2999 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
3000 +            CFException ex = new CFException();
3001 +            for (int i = 0; i < k; i++)
3002 +                fs[i] = new CompletableFuture<>();
3003 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
3004 +            for (int i = 0; i < k; i++) {
3005 +                checkIncomplete(f);
3006 +                checkIncomplete(CompletableFuture.allOf(fs));
3007 +                if (i != k/2) {
3008 +                    fs[i].complete(i);
3009 +                    checkCompletedNormally(fs[i], i);
3010 +                } else {
3011 +                    fs[i].completeExceptionally(ex);
3012 +                    checkCompletedExceptionally(fs[i], ex);
3013 +                }
3014 +            }
3015 +            checkCompletedWithWrappedException(f, ex);
3016 +            checkCompletedWithWrappedException(CompletableFuture.allOf(fs), ex);
3017 +        }
3018 +    }
3019 +
3020      /**
3021       * anyOf(no component futures) returns an incomplete future
3022       */
3023      public void testAnyOf_empty() throws Exception {
3024 +        for (Integer v1 : new Integer[] { 1, null })
3025 +    {
3026          CompletableFuture<Object> f = CompletableFuture.anyOf();
3027          checkIncomplete(f);
3028 <    }
3028 >
3029 >        f.complete(v1);
3030 >        checkCompletedNormally(f, v1);
3031 >    }}
3032  
3033      /**
3034       * anyOf returns a future completed normally with a value when
3035       * a component future does
3036       */
3037      public void testAnyOf_normal() throws Exception {
3038 <        for (int k = 0; k < 10; ++k) {
3038 >        for (int k = 0; k < 10; k++) {
3039              CompletableFuture[] fs = new CompletableFuture[k];
3040 <            for (int i = 0; i < k; ++i)
3040 >            for (int i = 0; i < k; i++)
3041                  fs[i] = new CompletableFuture<>();
3042              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3043              checkIncomplete(f);
3044 <            for (int i = 0; i < k; ++i) {
3045 <                fs[i].complete(one);
3046 <                checkCompletedNormally(f, one);
3047 <                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
3044 >            for (int i = 0; i < k; i++) {
3045 >                fs[i].complete(i);
3046 >                checkCompletedNormally(f, 0);
3047 >                int x = (int) CompletableFuture.anyOf(fs).join();
3048 >                assertTrue(0 <= x && x <= i);
3049 >            }
3050 >        }
3051 >    }
3052 >    public void testAnyOf_normal_backwards() throws Exception {
3053 >        for (int k = 0; k < 10; k++) {
3054 >            CompletableFuture[] fs = new CompletableFuture[k];
3055 >            for (int i = 0; i < k; i++)
3056 >                fs[i] = new CompletableFuture<>();
3057 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3058 >            checkIncomplete(f);
3059 >            for (int i = k - 1; i >= 0; i--) {
3060 >                fs[i].complete(i);
3061 >                checkCompletedNormally(f, k - 1);
3062 >                int x = (int) CompletableFuture.anyOf(fs).join();
3063 >                assertTrue(i <= x && x <= k - 1);
3064              }
3065          }
3066      }
# Line 2986 | Line 3069 | public class CompletableFutureTest exten
3069       * anyOf result completes exceptionally when any component does.
3070       */
3071      public void testAnyOf_exceptional() throws Exception {
3072 <        for (int k = 0; k < 10; ++k) {
3072 >        for (int k = 0; k < 10; k++) {
3073              CompletableFuture[] fs = new CompletableFuture[k];
3074 <            for (int i = 0; i < k; ++i)
3074 >            CFException[] exs = new CFException[k];
3075 >            for (int i = 0; i < k; i++) {
3076                  fs[i] = new CompletableFuture<>();
3077 +                exs[i] = new CFException();
3078 +            }
3079 +            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3080 +            checkIncomplete(f);
3081 +            for (int i = 0; i < k; i++) {
3082 +                fs[i].completeExceptionally(exs[i]);
3083 +                checkCompletedWithWrappedException(f, exs[0]);
3084 +                checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3085 +            }
3086 +        }
3087 +    }
3088 +
3089 +    public void testAnyOf_exceptional_backwards() throws Exception {
3090 +        for (int k = 0; k < 10; k++) {
3091 +            CompletableFuture[] fs = new CompletableFuture[k];
3092 +            CFException[] exs = new CFException[k];
3093 +            for (int i = 0; i < k; i++) {
3094 +                fs[i] = new CompletableFuture<>();
3095 +                exs[i] = new CFException();
3096 +            }
3097              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3098              checkIncomplete(f);
3099 <            for (int i = 0; i < k; ++i) {
3100 <                fs[i].completeExceptionally(new CFException());
3101 <                checkCompletedWithWrappedCFException(f);
3099 >            for (int i = k - 1; i >= 0; i--) {
3100 >                fs[i].completeExceptionally(exs[i]);
3101 >                checkCompletedWithWrappedException(f, exs[k - 1]);
3102                  checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
3103              }
3104          }
# Line 3137 | Line 3241 | public class CompletableFutureTest exten
3241          final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3242          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3243  
3244 <        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> dependentFactories
3244 >        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3245              = new ArrayList<>();
3246  
3247 <        dependentFactories.add((y) -> m.thenRun(y, new Noop(m)));
3248 <        dependentFactories.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3249 <        dependentFactories.add((y) -> m.thenApply(y, new IncFunction(m)));
3247 >        funs.add((y) -> m.thenRun(y, new Noop(m)));
3248 >        funs.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3249 >        funs.add((y) -> m.thenApply(y, new IncFunction(m)));
3250 >
3251 >        funs.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3252 >        funs.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3253 >        funs.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3254  
3255 <        dependentFactories.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3256 <        dependentFactories.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3257 <        dependentFactories.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3255 >        funs.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3256 >        funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3257 >        funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3258  
3259 <        dependentFactories.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3152 <        dependentFactories.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3153 <        dependentFactories.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3259 >        funs.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3260  
3261 <        dependentFactories.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3261 >        funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3262  
3263 <        dependentFactories.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3263 >        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
3264 >        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
3265  
3266          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3267 <                 dependentFactory : dependentFactories) {
3267 >                 fun : funs) {
3268              CompletableFuture<Integer> f = new CompletableFuture<>();
3269              f.completeExceptionally(ex);
3270              CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3271              checkCompletedWithWrappedException(src, ex);
3272 <            CompletableFuture<?> dep = dependentFactory.apply(src);
3272 >            CompletableFuture<?> dep = fun.apply(src);
3273              checkCompletedWithWrappedException(dep, ex);
3274              assertSame(resultOf(src), resultOf(dep));
3275          }
3276  
3277          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3278 <                 dependentFactory : dependentFactories) {
3278 >                 fun : funs) {
3279              CompletableFuture<Integer> f = new CompletableFuture<>();
3280              CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3281 <            CompletableFuture<?> dep = dependentFactory.apply(src);
3281 >            CompletableFuture<?> dep = fun.apply(src);
3282              f.completeExceptionally(ex);
3283              checkCompletedWithWrappedException(src, ex);
3284              checkCompletedWithWrappedException(dep, ex);
# Line 3180 | Line 3287 | public class CompletableFutureTest exten
3287  
3288          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3289          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3290 <                 dependentFactory : dependentFactories) {
3290 >                 fun : funs) {
3291              CompletableFuture<Integer> f = new CompletableFuture<>();
3292              f.cancel(mayInterruptIfRunning);
3293              checkCancelled(f);
3294              CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3295              checkCompletedWithWrappedCancellationException(src);
3296 <            CompletableFuture<?> dep = dependentFactory.apply(src);
3296 >            CompletableFuture<?> dep = fun.apply(src);
3297              checkCompletedWithWrappedCancellationException(dep);
3298              assertSame(resultOf(src), resultOf(dep));
3299          }
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              CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3306 <            CompletableFuture<?> dep = dependentFactory.apply(src);
3306 >            CompletableFuture<?> dep = fun.apply(src);
3307              f.cancel(mayInterruptIfRunning);
3308              checkCancelled(f);
3309              checkCompletedWithWrappedCancellationException(src);
# Line 3205 | Line 3312 | public class CompletableFutureTest exten
3312          }
3313      }}
3314  
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 –
3315   }

Diff Legend

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