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.156 by jsr166, Sun Jun 26 23:45:46 2016 UTC vs.
Revision 1.167 by jsr166, Sun Jul 17 17:49:23 2016 UTC

# Line 2700 | Line 2700 | public class CompletableFutureTest exten
2700          for (ExecutionMode m : ExecutionMode.values())
2701          for (Integer v1 : new Integer[] { 1, null })
2702          for (Integer v2 : new Integer[] { 2, null })
2703 +        for (boolean pushNop : new boolean[] { true, false })
2704      {
2705          final CompletableFuture<Integer> f = new CompletableFuture<>();
2706          final CompletableFuture<Integer> g = new CompletableFuture<>();
# Line 2712 | Line 2713 | public class CompletableFutureTest exten
2713          checkIncomplete(h1);
2714          rs[0].assertNotInvoked();
2715          rs[1].assertNotInvoked();
2716 +        if (pushNop) {          // ad hoc test of intra-completion interference
2717 +            m.thenRun(f, () -> {});
2718 +            m.thenRun(g, () -> {});
2719 +        }
2720          f.complete(v1);
2721          checkCompletedNormally(h0, null);
2722          checkCompletedNormally(h1, null);
# Line 3354 | Line 3359 | public class CompletableFutureTest exten
3359       * Test submissions to an executor that rejects all tasks.
3360       */
3361      public void testRejectingExecutor() {
3362 <        for (Integer v : new Integer[] { 1, null }) {
3363 <
3362 >        for (Integer v : new Integer[] { 1, null })
3363 >    {
3364          final CountingRejectingExecutor e = new CountingRejectingExecutor();
3365  
3366          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
# Line 3434 | Line 3439 | public class CompletableFutureTest exten
3439              checkCompletedWithWrappedException(future, e.ex);
3440  
3441          assertEquals(futures.size(), e.count.get());
3442 <
3438 <        }
3439 <    }
3442 >    }}
3443  
3444      /**
3445       * Test submissions to an executor that rejects all tasks, but
# Line 3444 | Line 3447 | public class CompletableFutureTest exten
3447       * explicitly completed.
3448       */
3449      public void testRejectingExecutorNeverInvoked() {
3450 +        for (Integer v : new Integer[] { 1, null })
3451 +    {
3452          final CountingRejectingExecutor e = new CountingRejectingExecutor();
3453  
3449 –        for (Integer v : new Integer[] { 1, null }) {
3450 –
3454          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3455          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3456  
# Line 3495 | Line 3498 | public class CompletableFutureTest exten
3498              checkCompletedNormally(future, null);
3499  
3500          assertEquals(0, e.count.get());
3501 <
3499 <        }
3500 <    }
3501 >    }}
3502  
3503      /**
3504       * toCompletableFuture returns this CompletableFuture.
# Line 3851 | Line 3852 | public class CompletableFutureTest exten
3852          final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3853          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3854  
3855 +        final Runnable noopRunnable = new Noop(m);
3856 +        final Consumer<Integer> noopConsumer = new NoopConsumer(m);
3857 +        final Function<Integer, Integer> incFunction = new IncFunction(m);
3858 +
3859          List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3860              = new ArrayList<>();
3861  
3862 <        funs.add((y) -> m.thenRun(y, new Noop(m)));
3863 <        funs.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3864 <        funs.add((y) -> m.thenApply(y, new IncFunction(m)));
3865 <
3866 <        funs.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3867 <        funs.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3868 <        funs.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3862 >        funs.add((y) -> m.thenRun(y, noopRunnable));
3863 >        funs.add((y) -> m.thenAccept(y, noopConsumer));
3864 >        funs.add((y) -> m.thenApply(y, incFunction));
3865 >
3866 >        funs.add((y) -> m.runAfterEither(y, incomplete, noopRunnable));
3867 >        funs.add((y) -> m.acceptEither(y, incomplete, noopConsumer));
3868 >        funs.add((y) -> m.applyToEither(y, incomplete, incFunction));
3869  
3870 <        funs.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3871 <        funs.add((y) -> m.runAfterBoth(v42, y, new Noop(m)));
3870 >        funs.add((y) -> m.runAfterBoth(y, v42, noopRunnable));
3871 >        funs.add((y) -> m.runAfterBoth(v42, y, noopRunnable));
3872          funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3873          funs.add((y) -> m.thenAcceptBoth(v42, y, new SubtractAction(m)));
3874          funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
# Line 3873 | Line 3878 | public class CompletableFutureTest exten
3878  
3879          funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3880  
3881 <        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y}));
3882 <        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
3883 <        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {v42, y}));
3884 <        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y}));
3885 <        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
3886 <        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {incomplete, y}));
3881 >        funs.add((y) -> CompletableFuture.allOf(y));
3882 >        funs.add((y) -> CompletableFuture.allOf(y, v42));
3883 >        funs.add((y) -> CompletableFuture.allOf(v42, y));
3884 >        funs.add((y) -> CompletableFuture.anyOf(y));
3885 >        funs.add((y) -> CompletableFuture.anyOf(y, incomplete));
3886 >        funs.add((y) -> CompletableFuture.anyOf(incomplete, y));
3887  
3888          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3889                   fun : funs) {
3890              CompletableFuture<Integer> f = new CompletableFuture<>();
3891              f.completeExceptionally(ex);
3892 <            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3892 >            CompletableFuture<Integer> src = m.thenApply(f, incFunction);
3893              checkCompletedWithWrappedException(src, ex);
3894              CompletableFuture<?> dep = fun.apply(src);
3895              checkCompletedWithWrappedException(dep, ex);
# Line 3894 | Line 3899 | public class CompletableFutureTest exten
3899          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3900                   fun : funs) {
3901              CompletableFuture<Integer> f = new CompletableFuture<>();
3902 <            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3902 >            CompletableFuture<Integer> src = m.thenApply(f, incFunction);
3903              CompletableFuture<?> dep = fun.apply(src);
3904              f.completeExceptionally(ex);
3905              checkCompletedWithWrappedException(src, ex);
# Line 3908 | Line 3913 | public class CompletableFutureTest exten
3913              CompletableFuture<Integer> f = new CompletableFuture<>();
3914              f.cancel(mayInterruptIfRunning);
3915              checkCancelled(f);
3916 <            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3916 >            CompletableFuture<Integer> src = m.thenApply(f, incFunction);
3917              checkCompletedWithWrappedCancellationException(src);
3918              CompletableFuture<?> dep = fun.apply(src);
3919              checkCompletedWithWrappedCancellationException(dep);
# Line 3919 | Line 3924 | public class CompletableFutureTest exten
3924          for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3925                   fun : funs) {
3926              CompletableFuture<Integer> f = new CompletableFuture<>();
3927 <            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3927 >            CompletableFuture<Integer> src = m.thenApply(f, incFunction);
3928              CompletableFuture<?> dep = fun.apply(src);
3929              f.cancel(mayInterruptIfRunning);
3930              checkCancelled(f);
# Line 3930 | Line 3935 | public class CompletableFutureTest exten
3935      }}
3936  
3937      /**
3938 <     * Minimal completion stages throw UOE for all non-CompletionStage methods
3938 >     * Minimal completion stages throw UOE for most non-CompletionStage methods
3939       */
3940      public void testMinimalCompletionStage_minimality() {
3941          if (!testImplementationDetails) return;
# Line 3959 | Line 3964 | public class CompletableFutureTest exten
3964              .filter((method) -> !permittedMethodSignatures.contains(toSignature.apply(method)))
3965              .collect(Collectors.toList());
3966  
3967 <        CompletionStage<Integer> minimalStage =
3968 <            new CompletableFuture<Integer>().minimalCompletionStage();
3967 >        List<CompletionStage<Integer>> stages = new ArrayList<>();
3968 >        stages.add(new CompletableFuture<Integer>().minimalCompletionStage());
3969 >        stages.add(CompletableFuture.completedStage(1));
3970 >        stages.add(CompletableFuture.failedStage(new CFException()));
3971  
3972          List<Method> bugs = new ArrayList<>();
3973          for (Method method : allMethods) {
# Line 3976 | Line 3983 | public class CompletableFutureTest exten
3983                  else if (parameterTypes[i] == long.class)
3984                      args[i] = 0L;
3985              }
3986 <            try {
3987 <                method.invoke(minimalStage, args);
3988 <                bugs.add(method);
3982 <            }
3983 <            catch (java.lang.reflect.InvocationTargetException expected) {
3984 <                if (! (expected.getCause() instanceof UnsupportedOperationException)) {
3986 >            for (CompletionStage<Integer> stage : stages) {
3987 >                try {
3988 >                    method.invoke(stage, args);
3989                      bugs.add(method);
3986 –                    // expected.getCause().printStackTrace();
3990                  }
3991 +                catch (java.lang.reflect.InvocationTargetException expected) {
3992 +                    if (! (expected.getCause() instanceof UnsupportedOperationException)) {
3993 +                        bugs.add(method);
3994 +                        // expected.getCause().printStackTrace();
3995 +                    }
3996 +                }
3997 +                catch (ReflectiveOperationException bad) { throw new Error(bad); }
3998              }
3989 –            catch (ReflectiveOperationException bad) { throw new Error(bad); }
3999          }
4000          if (!bugs.isEmpty())
4001 <            throw new Error("Methods did not throw UOE: " + bugs.toString());
4001 >            throw new Error("Methods did not throw UOE: " + bugs);
4002      }
4003  
4004      static class Monad {
# Line 4138 | Line 4147 | public class CompletableFutureTest exten
4147                                   Monad.plus(godot, Monad.unit(5L)));
4148      }
4149  
4150 +    /** Test long recursive chains of CompletableFutures with cascading completions */
4151 +    public void testRecursiveChains() throws Throwable {
4152 +        for (ExecutionMode m : ExecutionMode.values())
4153 +        for (boolean addDeadEnds : new boolean[] { true, false })
4154 +    {
4155 +        final int val = 42;
4156 +        final int n = expensiveTests ? 1_000 : 2;
4157 +        CompletableFuture<Integer> head = new CompletableFuture<>();
4158 +        CompletableFuture<Integer> tail = head;
4159 +        for (int i = 0; i < n; i++) {
4160 +            if (addDeadEnds) m.thenApply(tail, v -> v + 1);
4161 +            tail = m.thenApply(tail, v -> v + 1);
4162 +            if (addDeadEnds) m.applyToEither(tail, tail, v -> v + 1);
4163 +            tail = m.applyToEither(tail, tail, v -> v + 1);
4164 +            if (addDeadEnds) m.thenCombine(tail, tail, (v, w) -> v + 1);
4165 +            tail = m.thenCombine(tail, tail, (v, w) -> v + 1);
4166 +        }
4167 +        head.complete(val);
4168 +        assertEquals(val + 3 * n, (int) tail.join());
4169 +    }}
4170 +
4171      /**
4172       * A single CompletableFuture with many dependents.
4173       * A demo of scalability - runtime is O(n).
4174       */
4175      public void testManyDependents() throws Throwable {
4176 <        final int n = 1_000;
4176 >        final int n = expensiveTests ? 1_000_000 : 10;
4177          final CompletableFuture<Void> head = new CompletableFuture<>();
4178          final CompletableFuture<Void> complete = CompletableFuture.completedFuture((Void)null);
4179          final AtomicInteger count = new AtomicInteger(0);
# Line 4170 | Line 4200 | public class CompletableFutureTest exten
4200          assertEquals(5 * 3 * n, count.get());
4201      }
4202  
4203 <    /** a66 -Dvmoptions=-Xmx8m -Djsr166.tckTestClass=CompletableFutureTest tck */
4204 <    public void testCoCompletionGarbage() throws Throwable {
4205 <        // final int n = 3_000_000;
4176 <        final int n = 100;
4203 >    /** ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest tck */
4204 >    public void testCoCompletionGarbageRetention() throws Throwable {
4205 >        final int n = expensiveTests ? 1_000_000 : 10;
4206          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
4207          CompletableFuture<Integer> f;
4208          for (int i = 0; i < n; i++) {
# Line 4213 | Line 4242 | public class CompletableFutureTest exten
4242          }
4243      }
4244  
4245 +    /**
4246 +     * Checks for garbage retention with anyOf.
4247 +     * Following used to fail with OOME:
4248 +     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testAnyOfGarbageRetention tck
4249 +     */
4250 +    public void testAnyOfGarbageRetention() throws Throwable {
4251 +        for (Integer v : new Integer[] { 1, null })
4252 +    {
4253 +        final int n = expensiveTests ? 100_000 : 10;
4254 +        CompletableFuture<Integer>[] fs
4255 +            = (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4256 +        for (int i = 0; i < fs.length; i++)
4257 +            fs[i] = new CompletableFuture<>();
4258 +        fs[fs.length - 1].complete(v);
4259 +        for (int i = 0; i < n; i++)
4260 +            checkCompletedNormally(CompletableFuture.anyOf(fs), v);
4261 +    }}
4262 +
4263 +    /**
4264 +     * Checks for garbage retention with allOf.
4265 +     *
4266 +     * As of 2016-07, fails with OOME:
4267 +     * ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testCancelledAllOfGarbageRetention tck
4268 +     */
4269 +    public void testCancelledAllOfGarbageRetention() throws Throwable {
4270 +        final int n = expensiveTests ? 100_000 : 10;
4271 +        CompletableFuture<Integer>[] fs
4272 +            = (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4273 +        for (int i = 0; i < fs.length; i++)
4274 +            fs[i] = new CompletableFuture<>();
4275 +        for (int i = 0; i < n; i++)
4276 +            assertTrue(CompletableFuture.allOf(fs).cancel(false));
4277 +    }
4278 +
4279   //     static <U> U join(CompletionStage<U> stage) {
4280   //         CompletableFuture<U> f = new CompletableFuture<>();
4281   //         stage.whenComplete((v, ex) -> {

Diff Legend

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