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.165 by jsr166, Sun Jul 3 19:35:50 2016 UTC vs.
Revision 1.172 by jsr166, Thu Sep 15 00:32:45 2016 UTC

# Line 32 | Line 32 | import java.util.concurrent.ForkJoinPool
32   import java.util.concurrent.ForkJoinTask;
33   import java.util.concurrent.RejectedExecutionException;
34   import java.util.concurrent.TimeoutException;
35 – import java.util.concurrent.TimeUnit;
35   import java.util.concurrent.atomic.AtomicInteger;
36   import java.util.concurrent.atomic.AtomicReference;
37   import java.util.function.BiConsumer;
# Line 362 | Line 361 | public class CompletableFutureTest exten
361          checkCompletedNormally(f, "test");
362      }
363  
364 <    abstract class CheckedAction {
364 >    abstract static class CheckedAction {
365          int invocationCount = 0;
366          final ExecutionMode m;
367          CheckedAction(ExecutionMode m) { this.m = m; }
# Line 374 | Line 373 | public class CompletableFutureTest exten
373          void assertInvoked() { assertEquals(1, invocationCount); }
374      }
375  
376 <    abstract class CheckedIntegerAction extends CheckedAction {
376 >    abstract static class CheckedIntegerAction extends CheckedAction {
377          Integer value;
378          CheckedIntegerAction(ExecutionMode m) { super(m); }
379          void assertValue(Integer expected) {
# Line 383 | Line 382 | public class CompletableFutureTest exten
382          }
383      }
384  
385 <    class IntegerSupplier extends CheckedAction
385 >    static class IntegerSupplier extends CheckedAction
386          implements Supplier<Integer>
387      {
388          final Integer value;
# Line 402 | Line 401 | public class CompletableFutureTest exten
401          return (x == null) ? null : x + 1;
402      }
403  
404 <    class NoopConsumer extends CheckedIntegerAction
404 >    static class NoopConsumer extends CheckedIntegerAction
405          implements Consumer<Integer>
406      {
407          NoopConsumer(ExecutionMode m) { super(m); }
# Line 412 | Line 411 | public class CompletableFutureTest exten
411          }
412      }
413  
414 <    class IncFunction extends CheckedIntegerAction
414 >    static class IncFunction extends CheckedIntegerAction
415          implements Function<Integer,Integer>
416      {
417          IncFunction(ExecutionMode m) { super(m); }
# Line 430 | Line 429 | public class CompletableFutureTest exten
429              - ((y == null) ? 99 : y.intValue());
430      }
431  
432 <    class SubtractAction extends CheckedIntegerAction
432 >    static class SubtractAction extends CheckedIntegerAction
433          implements BiConsumer<Integer, Integer>
434      {
435          SubtractAction(ExecutionMode m) { super(m); }
# Line 440 | Line 439 | public class CompletableFutureTest exten
439          }
440      }
441  
442 <    class SubtractFunction extends CheckedIntegerAction
442 >    static class SubtractFunction extends CheckedIntegerAction
443          implements BiFunction<Integer, Integer, Integer>
444      {
445          SubtractFunction(ExecutionMode m) { super(m); }
# Line 450 | Line 449 | public class CompletableFutureTest exten
449          }
450      }
451  
452 <    class Noop extends CheckedAction implements Runnable {
452 >    static class Noop extends CheckedAction implements Runnable {
453          Noop(ExecutionMode m) { super(m); }
454          public void run() {
455              invoked();
456          }
457      }
458  
459 <    class FailingSupplier extends CheckedAction
459 >    static class FailingSupplier extends CheckedAction
460          implements Supplier<Integer>
461      {
462          final CFException ex;
# Line 468 | Line 467 | public class CompletableFutureTest exten
467          }
468      }
469  
470 <    class FailingConsumer extends CheckedIntegerAction
470 >    static class FailingConsumer extends CheckedIntegerAction
471          implements Consumer<Integer>
472      {
473          final CFException ex;
# Line 480 | Line 479 | public class CompletableFutureTest exten
479          }
480      }
481  
482 <    class FailingBiConsumer extends CheckedIntegerAction
482 >    static class FailingBiConsumer extends CheckedIntegerAction
483          implements BiConsumer<Integer, Integer>
484      {
485          final CFException ex;
# Line 492 | Line 491 | public class CompletableFutureTest exten
491          }
492      }
493  
494 <    class FailingFunction extends CheckedIntegerAction
494 >    static class FailingFunction extends CheckedIntegerAction
495          implements Function<Integer, Integer>
496      {
497          final CFException ex;
# Line 504 | Line 503 | public class CompletableFutureTest exten
503          }
504      }
505  
506 <    class FailingBiFunction extends CheckedIntegerAction
506 >    static class FailingBiFunction extends CheckedIntegerAction
507          implements BiFunction<Integer, Integer, Integer>
508      {
509          final CFException ex;
# Line 516 | Line 515 | public class CompletableFutureTest exten
515          }
516      }
517  
518 <    class FailingRunnable extends CheckedAction implements Runnable {
518 >    static class FailingRunnable extends CheckedAction implements Runnable {
519          final CFException ex;
520          FailingRunnable(ExecutionMode m) { super(m); ex = new CFException(); }
521          public void run() {
# Line 525 | Line 524 | public class CompletableFutureTest exten
524          }
525      }
526  
527 <    class CompletableFutureInc extends CheckedIntegerAction
527 >    static class CompletableFutureInc extends CheckedIntegerAction
528          implements Function<Integer, CompletableFuture<Integer>>
529      {
530          CompletableFutureInc(ExecutionMode m) { super(m); }
# Line 538 | Line 537 | public class CompletableFutureTest exten
537          }
538      }
539  
540 <    class FailingCompletableFutureFunction extends CheckedIntegerAction
540 >    static class FailingCompletableFutureFunction extends CheckedIntegerAction
541          implements Function<Integer, CompletableFuture<Integer>>
542      {
543          final CFException ex;
# Line 3967 | Line 3966 | public class CompletableFutureTest exten
3966          List<CompletionStage<Integer>> stages = new ArrayList<>();
3967          stages.add(new CompletableFuture<Integer>().minimalCompletionStage());
3968          stages.add(CompletableFuture.completedStage(1));
3969 +        stages.add(CompletableFuture.failedStage(new CFException()));
3970  
3971          List<Method> bugs = new ArrayList<>();
3972          for (Method method : allMethods) {
# Line 4241 | Line 4241 | public class CompletableFutureTest exten
4241          }
4242      }
4243  
4244 <    /*
4245 <     * Tests below currently fail in stress mode due to memory retention.
4246 <     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest tck
4244 >    /**
4245 >     * Reproduction recipe for:
4246 >     * 8160402: Garbage retention with CompletableFuture.anyOf
4247 >     * cvs update -D '2016-05-01' ./src/main/java/util/concurrent/CompletableFuture.java && ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testAnyOfGarbageRetention tck; cvs update -A
4248       */
4248 –
4249 –    /** Checks for garbage retention with anyOf. */
4249      public void testAnyOfGarbageRetention() throws Throwable {
4250          for (Integer v : new Integer[] { 1, null })
4251      {
# Line 4260 | Line 4259 | public class CompletableFutureTest exten
4259              checkCompletedNormally(CompletableFuture.anyOf(fs), v);
4260      }}
4261  
4262 <    /** Checks for garbage retention with allOf. */
4262 >    /**
4263 >     * Checks for garbage retention with allOf.
4264 >     *
4265 >     * As of 2016-07, fails with OOME:
4266 >     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testCancelledAllOfGarbageRetention tck
4267 >     */
4268      public void testCancelledAllOfGarbageRetention() throws Throwable {
4269          final int n = expensiveTests ? 100_000 : 10;
4270          CompletableFuture<Integer>[] fs
# Line 4271 | Line 4275 | public class CompletableFutureTest exten
4275              assertTrue(CompletableFuture.allOf(fs).cancel(false));
4276      }
4277  
4278 +    /**
4279 +     * Checks for garbage retention when a dependent future is
4280 +     * cancelled and garbage-collected.
4281 +     * 8161600: Garbage retention when source CompletableFutures are never completed
4282 +     *
4283 +     * As of 2016-07, fails with OOME:
4284 +     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testCancelledGarbageRetention tck
4285 +     */
4286 +    public void testCancelledGarbageRetention() throws Throwable {
4287 +        final int n = expensiveTests ? 100_000 : 10;
4288 +        CompletableFuture<Integer> neverCompleted = new CompletableFuture<>();
4289 +        for (int i = 0; i < n; i++)
4290 +            assertTrue(neverCompleted.thenRun(() -> {}).cancel(true));
4291 +    }
4292 +
4293   //     static <U> U join(CompletionStage<U> stage) {
4294   //         CompletableFuture<U> f = new CompletableFuture<>();
4295   //         stage.whenComplete((v, ex) -> {

Diff Legend

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