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.173 by jsr166, Wed Sep 21 06:03:17 2016 UTC vs.
Revision 1.179 by jsr166, Thu Sep 22 22:05:49 2016 UTC

# Line 3577 | Line 3577 | public class CompletableFutureTest exten
3577       * copy returns a CompletableFuture that is completed normally,
3578       * with the same value, when source is.
3579       */
3580 <    public void testCopy() {
3580 >    public void testCopy_normalCompletion() {
3581 >        for (boolean createIncomplete : new boolean[] { true, false })
3582 >        for (Integer v1 : new Integer[] { 1, null })
3583 >    {
3584          CompletableFuture<Integer> f = new CompletableFuture<>();
3585 +        if (!createIncomplete) assertTrue(f.complete(v1));
3586          CompletableFuture<Integer> g = f.copy();
3587 <        checkIncomplete(f);
3588 <        checkIncomplete(g);
3589 <        f.complete(1);
3590 <        checkCompletedNormally(f, 1);
3591 <        checkCompletedNormally(g, 1);
3592 <    }
3587 >        if (createIncomplete) {
3588 >            checkIncomplete(f);
3589 >            checkIncomplete(g);
3590 >            assertTrue(f.complete(v1));
3591 >        }
3592 >        checkCompletedNormally(f, v1);
3593 >        checkCompletedNormally(g, v1);
3594 >    }}
3595  
3596      /**
3597       * copy returns a CompletableFuture that is completed exceptionally
3598       * when source is.
3599       */
3600 <    public void testCopy2() {
3600 >    public void testCopy_exceptionalCompletion() {
3601 >        for (boolean createIncomplete : new boolean[] { true, false })
3602 >    {
3603 >        CFException ex = new CFException();
3604          CompletableFuture<Integer> f = new CompletableFuture<>();
3605 +        if (!createIncomplete) f.completeExceptionally(ex);
3606          CompletableFuture<Integer> g = f.copy();
3607 <        checkIncomplete(f);
3608 <        checkIncomplete(g);
3609 <        CFException ex = new CFException();
3610 <        f.completeExceptionally(ex);
3607 >        if (createIncomplete) {
3608 >            checkIncomplete(f);
3609 >            checkIncomplete(g);
3610 >            f.completeExceptionally(ex);
3611 >        }
3612          checkCompletedExceptionally(f, ex);
3613          checkCompletedWithWrappedException(g, ex);
3614 +    }}
3615 +
3616 +    /**
3617 +     * Completion of a copy does not complete its source.
3618 +     */
3619 +    public void testCopy_oneWayPropagation() {
3620 +        CompletableFuture<Integer> f = new CompletableFuture<>();
3621 +        assertTrue(f.copy().complete(1));
3622 +        assertTrue(f.copy().complete(null));
3623 +        assertTrue(f.copy().cancel(true));
3624 +        assertTrue(f.copy().cancel(false));
3625 +        assertTrue(f.copy().completeExceptionally(new CFException()));
3626 +        checkIncomplete(f);
3627      }
3628  
3629      /**
# Line 4004 | Line 4028 | public class CompletableFutureTest exten
4028      }
4029  
4030      /**
4031 +     * minimalStage.toCompletableFuture() returns a CompletableFuture that
4032 +     * is completed normally, with the same value, when source is.
4033 +     */
4034 +    public void testMinimalCompletionStage_toCompletableFuture_normalCompletion() {
4035 +        for (boolean createIncomplete : new boolean[] { true, false })
4036 +        for (Integer v1 : new Integer[] { 1, null })
4037 +    {
4038 +        CompletableFuture<Integer> f = new CompletableFuture<>();
4039 +        CompletionStage<Integer> minimal = f.minimalCompletionStage();
4040 +        if (!createIncomplete) assertTrue(f.complete(v1));
4041 +        CompletableFuture<Integer> g = minimal.toCompletableFuture();
4042 +        if (createIncomplete) {
4043 +            checkIncomplete(f);
4044 +            checkIncomplete(g);
4045 +            assertTrue(f.complete(v1));
4046 +        }
4047 +        checkCompletedNormally(f, v1);
4048 +        checkCompletedNormally(g, v1);
4049 +    }}
4050 +
4051 +    /**
4052 +     * minimalStage.toCompletableFuture() returns a CompletableFuture that
4053 +     * is completed exceptionally when source is.
4054 +     */
4055 +    public void testMinimalCompletionStage_toCompletableFuture_exceptionalCompletion() {
4056 +        for (boolean createIncomplete : new boolean[] { true, false })
4057 +    {
4058 +        CFException ex = new CFException();
4059 +        CompletableFuture<Integer> f = new CompletableFuture<>();
4060 +        CompletionStage<Integer> minimal = f.minimalCompletionStage();
4061 +        if (!createIncomplete) f.completeExceptionally(ex);
4062 +        CompletableFuture<Integer> g = minimal.toCompletableFuture();
4063 +        if (createIncomplete) {
4064 +            checkIncomplete(f);
4065 +            checkIncomplete(g);
4066 +            f.completeExceptionally(ex);
4067 +        }
4068 +        checkCompletedExceptionally(f, ex);
4069 +        checkCompletedWithWrappedException(g, ex);
4070 +    }}
4071 +
4072 +    /**
4073       * minimalStage.toCompletableFuture() gives mutable CompletableFuture
4074       */
4075      public void testMinimalCompletionStage_toCompletableFuture_mutable() {
# Line 4012 | Line 4078 | public class CompletableFutureTest exten
4078          CompletableFuture<Integer> f = new CompletableFuture<>();
4079          CompletionStage minimal = f.minimalCompletionStage();
4080          CompletableFuture<Integer> g = minimal.toCompletableFuture();
4081 <        g.complete(v1);
4081 >        assertTrue(g.complete(v1));
4082          checkCompletedNormally(g, v1);
4083          checkIncomplete(f);
4084          checkIncomplete(minimal.toCompletableFuture());
# Line 4034 | Line 4100 | public class CompletableFutureTest exten
4100          checkCompletedNormally(minimal.toCompletableFuture(), v1);
4101      }}
4102  
4103 +    /**
4104 +     * Completion of a toCompletableFuture copy of a minimal stage
4105 +     * does not complete its source.
4106 +     */
4107 +    public void testMinimalCompletionStage_toCompletableFuture_oneWayPropagation() {
4108 +        CompletableFuture<Integer> f = new CompletableFuture<>();
4109 +        CompletionStage<Integer> g = f.minimalCompletionStage();
4110 +        assertTrue(g.toCompletableFuture().complete(1));
4111 +        assertTrue(g.toCompletableFuture().complete(null));
4112 +        assertTrue(g.toCompletableFuture().cancel(true));
4113 +        assertTrue(g.toCompletableFuture().cancel(false));
4114 +        assertTrue(g.toCompletableFuture().completeExceptionally(new CFException()));
4115 +        checkIncomplete(g.toCompletableFuture());
4116 +        f.complete(1);
4117 +        checkCompletedNormally(g.toCompletableFuture(), 1);
4118 +    }
4119 +
4120      /** Demo utility method for external reliable toCompletableFuture */
4121      static <T> CompletableFuture<T> toCompletableFuture(CompletionStage<T> stage) {
4122          CompletableFuture<T> f = new CompletableFuture<>();
# Line 4359 | Line 4442 | public class CompletableFutureTest exten
4442              assertTrue(neverCompleted.thenRun(() -> {}).cancel(true));
4443      }
4444  
4445 +    /**
4446 +     * Checks for garbage retention when MinimalStage.toCompletableFuture()
4447 +     * is invoked many times.
4448 +     * 8161600: Garbage retention when source CompletableFutures are never completed
4449 +     *
4450 +     * As of 2016-07, fails with OOME:
4451 +     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testToCompletableFutureGarbageRetention tck
4452 +     */
4453 +    public void testToCompletableFutureGarbageRetention() throws Throwable {
4454 +        final int n = expensiveTests ? 900_000 : 10;
4455 +        CompletableFuture<Integer> neverCompleted = new CompletableFuture<>();
4456 +        CompletionStage minimal = neverCompleted.minimalCompletionStage();
4457 +        for (int i = 0; i < n; i++)
4458 +            assertTrue(minimal.toCompletableFuture().cancel(true));
4459 +    }
4460 +
4461   //     static <U> U join(CompletionStage<U> stage) {
4462   //         CompletableFuture<U> f = new CompletableFuture<>();
4463   //         stage.whenComplete((v, ex) -> {

Diff Legend

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