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.152 by jsr166, Sun Jun 26 19:03:27 2016 UTC vs.
Revision 1.159 by jsr166, Mon Jun 27 21:39:37 2016 UTC

# Line 550 | Line 550 | public class CompletableFutureTest exten
550          }
551      }
552  
553 +    static class CountingRejectingExecutor implements Executor {
554 +        final RejectedExecutionException ex = new RejectedExecutionException();
555 +        final AtomicInteger count = new AtomicInteger(0);
556 +        public void execute(Runnable r) {
557 +            count.getAndIncrement();
558 +            throw ex;
559 +        }
560 +    }
561 +
562      // Used for explicit executor tests
563      static final class ThreadExecutor implements Executor {
564          final AtomicInteger count = new AtomicInteger(0);
# Line 1234 | Line 1243 | public class CompletableFutureTest exten
1243          r.assertInvoked();
1244      }}
1245  
1246 +    public void testRunAsync_rejectingExecutor() {
1247 +        CountingRejectingExecutor e = new CountingRejectingExecutor();
1248 +        try {
1249 +            CompletableFuture.runAsync(() -> {}, e);
1250 +            shouldThrow();
1251 +        } catch (Throwable t) {
1252 +            assertSame(e.ex, t);
1253 +        }
1254 +
1255 +        assertEquals(1, e.count.get());
1256 +    }
1257 +
1258      /**
1259       * supplyAsync completes with result of supplier
1260       */
# Line 1268 | Line 1289 | public class CompletableFutureTest exten
1289          r.assertInvoked();
1290      }}
1291  
1292 +    public void testSupplyAsync_rejectingExecutor() {
1293 +        CountingRejectingExecutor e = new CountingRejectingExecutor();
1294 +        try {
1295 +            CompletableFuture.supplyAsync(() -> null, e);
1296 +            shouldThrow();
1297 +        } catch (Throwable t) {
1298 +            assertSame(e.ex, t);
1299 +        }
1300 +
1301 +        assertEquals(1, e.count.get());
1302 +    }
1303 +
1304      // seq completion methods
1305  
1306      /**
# Line 3321 | Line 3354 | public class CompletableFutureTest exten
3354       * Test submissions to an executor that rejects all tasks.
3355       */
3356      public void testRejectingExecutor() {
3324 –        final RejectedExecutionException ex = new RejectedExecutionException();
3325 –        final Executor e = (Runnable r) -> { throw ex; };
3326 –
3357          for (Integer v : new Integer[] { 1, null }) {
3358  
3359 +        final CountingRejectingExecutor e = new CountingRejectingExecutor();
3360 +
3361          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3362          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3363  
# Line 3355 | Line 3387 | public class CompletableFutureTest exten
3387  
3388              for (CompletableFuture<?> future : fs) {
3389                  if (src.isDone())
3390 <                    checkCompletedWithWrappedException(future, ex);
3390 >                    checkCompletedWithWrappedException(future, e.ex);
3391                  else
3392                      checkIncomplete(future);
3393              }
# Line 3392 | Line 3424 | public class CompletableFutureTest exten
3424              fs.add(incomplete.runAfterEitherAsync(complete, () -> {}, e));
3425  
3426              for (CompletableFuture<?> future : fs)
3427 <                checkCompletedWithWrappedException(future, ex);
3427 >                checkCompletedWithWrappedException(future, e.ex);
3428              futures.addAll(fs);
3429          }
3430  
3431          incomplete.complete(v);
3432  
3433          for (CompletableFuture<?> future : futures)
3434 <            checkCompletedWithWrappedException(future, ex);
3434 >            checkCompletedWithWrappedException(future, e.ex);
3435 >
3436 >        assertEquals(futures.size(), e.count.get());
3437 >
3438 >        }
3439 >    }
3440 >
3441 >    /**
3442 >     * Test submissions to an executor that rejects all tasks, but
3443 >     * should never be invoked because the dependent future is
3444 >     * explicitly completed.
3445 >     */
3446 >    public void testRejectingExecutorNeverInvoked() {
3447 >        final CountingRejectingExecutor e = new CountingRejectingExecutor();
3448 >
3449 >        for (Integer v : new Integer[] { 1, null }) {
3450 >
3451 >        final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3452 >        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3453 >
3454 >        List<CompletableFuture<?>> futures = new ArrayList<>();
3455 >
3456 >        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3457 >        srcs.add(complete);
3458 >        srcs.add(incomplete);
3459 >
3460 >        List<CompletableFuture<?>> fs = new ArrayList<>();
3461 >        fs.add(incomplete.thenRunAsync(() -> {}, e));
3462 >        fs.add(incomplete.thenAcceptAsync((z) -> {}, e));
3463 >        fs.add(incomplete.thenApplyAsync((z) -> z, e));
3464 >
3465 >        fs.add(incomplete.thenCombineAsync(incomplete, (x, y) -> x, e));
3466 >        fs.add(incomplete.thenAcceptBothAsync(incomplete, (x, y) -> {}, e));
3467 >        fs.add(incomplete.runAfterBothAsync(incomplete, () -> {}, e));
3468 >
3469 >        fs.add(incomplete.applyToEitherAsync(incomplete, (z) -> z, e));
3470 >        fs.add(incomplete.acceptEitherAsync(incomplete, (z) -> {}, e));
3471 >        fs.add(incomplete.runAfterEitherAsync(incomplete, () -> {}, e));
3472 >
3473 >        fs.add(incomplete.thenComposeAsync((z) -> null, e));
3474 >        fs.add(incomplete.whenCompleteAsync((z, t) -> {}, e));
3475 >        fs.add(incomplete.handleAsync((z, t) -> null, e));
3476 >
3477 >        fs.add(complete.thenCombineAsync(incomplete, (x, y) -> x, e));
3478 >        fs.add(incomplete.thenCombineAsync(complete, (x, y) -> x, e));
3479 >
3480 >        fs.add(complete.thenAcceptBothAsync(incomplete, (x, y) -> {}, e));
3481 >        fs.add(incomplete.thenAcceptBothAsync(complete, (x, y) -> {}, e));
3482 >
3483 >        fs.add(complete.runAfterBothAsync(incomplete, () -> {}, e));
3484 >        fs.add(incomplete.runAfterBothAsync(complete, () -> {}, e));
3485 >
3486 >        for (CompletableFuture<?> future : fs)
3487 >            checkIncomplete(future);
3488 >
3489 >        for (CompletableFuture<?> future : fs)
3490 >            future.complete(null);
3491 >
3492 >        incomplete.complete(v);
3493 >
3494 >        for (CompletableFuture<?> future : fs)
3495 >            checkCompletedNormally(future, null);
3496 >
3497 >        assertEquals(0, e.count.get());
3498 >
3499          }
3500      }
3501  
# Line 4047 | Line 4143 | public class CompletableFutureTest exten
4143       * A demo of scalability - runtime is O(n).
4144       */
4145      public void testManyDependents() throws Throwable {
4146 <        final int n = 1_000;
4146 >        final int n = expensiveTests ? 1_000_000 : 10;
4147          final CompletableFuture<Void> head = new CompletableFuture<>();
4148          final CompletableFuture<Void> complete = CompletableFuture.completedFuture((Void)null);
4149          final AtomicInteger count = new AtomicInteger(0);
# Line 4074 | Line 4170 | public class CompletableFutureTest exten
4170          assertEquals(5 * 3 * n, count.get());
4171      }
4172  
4173 +    /** ant -Dvmoptions=-Xmx8m -Djsr166.tckTestClass=CompletableFutureTest tck */
4174 +    public void testCoCompletionGarbage() throws Throwable {
4175 +        final int n = expensiveTests ? 1_000_000 : 10;
4176 +        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
4177 +        CompletableFuture<Integer> f;
4178 +        for (int i = 0; i < n; i++) {
4179 +            f = new CompletableFuture<>();
4180 +            f.runAfterEither(incomplete, () -> {});
4181 +            f.complete(null);
4182 +
4183 +            f = new CompletableFuture<>();
4184 +            f.acceptEither(incomplete, (x) -> {});
4185 +            f.complete(null);
4186 +
4187 +            f = new CompletableFuture<>();
4188 +            f.applyToEither(incomplete, (x) -> x);
4189 +            f.complete(null);
4190 +
4191 +            f = new CompletableFuture<>();
4192 +            CompletableFuture.anyOf(new CompletableFuture<?>[] { f, incomplete });
4193 +            f.complete(null);
4194 +        }
4195 +
4196 +        for (int i = 0; i < n; i++) {
4197 +            f = new CompletableFuture<>();
4198 +            incomplete.runAfterEither(f, () -> {});
4199 +            f.complete(null);
4200 +
4201 +            f = new CompletableFuture<>();
4202 +            incomplete.acceptEither(f, (x) -> {});
4203 +            f.complete(null);
4204 +
4205 +            f = new CompletableFuture<>();
4206 +            incomplete.applyToEither(f, (x) -> x);
4207 +            f.complete(null);
4208 +
4209 +            f = new CompletableFuture<>();
4210 +            CompletableFuture.anyOf(new CompletableFuture<?>[] { incomplete, f });
4211 +            f.complete(null);
4212 +        }
4213 +    }
4214 +
4215 +    /*
4216 +     * Tests below currently fail in stress mode due to memory retention.
4217 +     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest tck
4218 +     */
4219 +
4220 +    /** Checks for garbage retention with anyOf. */
4221 +    public void testAnyOfGarbageRetention() throws Throwable {
4222 +        for (Integer v : new Integer[] { 1, null })
4223 +    {
4224 +        final int n = expensiveTests ? 100_000 : 10;
4225 +        CompletableFuture<Integer>[] fs
4226 +            = (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4227 +        for (int i = 0; i < fs.length; i++)
4228 +            fs[i] = new CompletableFuture<>();
4229 +        fs[fs.length - 1].complete(v);
4230 +        for (int i = 0; i < n; i++)
4231 +            checkCompletedNormally(CompletableFuture.anyOf(fs), v);
4232 +    }}
4233 +
4234 +    /** Checks for garbage retention with allOf. */
4235 +    public void testCancelledAllOfGarbageRetention() throws Throwable {
4236 +        final int n = expensiveTests ? 100_000 : 10;
4237 +        CompletableFuture<Integer>[] fs
4238 +            = (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4239 +        for (int i = 0; i < fs.length; i++)
4240 +            fs[i] = new CompletableFuture<>();
4241 +        for (int i = 0; i < n; i++)
4242 +            assertTrue(CompletableFuture.allOf(fs).cancel(false));
4243 +    }
4244 +
4245   //     static <U> U join(CompletionStage<U> stage) {
4246   //         CompletableFuture<U> f = new CompletableFuture<>();
4247   //         stage.whenComplete((v, ex) -> {

Diff Legend

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