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.82 by jsr166, Mon Jun 16 18:04:07 2014 UTC vs.
Revision 1.86 by jsr166, Mon Jun 16 21:04:23 2014 UTC

# Line 2922 | Line 2922 | public class CompletableFutureTest exten
2922       * when all components complete normally
2923       */
2924      public void testAllOf_normal() throws Exception {
2925 <        for (int k = 1; k < 20; ++k) {
2925 >        for (int k = 1; k < 20; k++) {
2926              CompletableFuture<Integer>[] fs
2927                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2928 <            for (int i = 0; i < k; ++i)
2928 >            for (int i = 0; i < k; i++)
2929                  fs[i] = new CompletableFuture<>();
2930              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2931 <            for (int i = 0; i < k; ++i) {
2931 >            for (int i = 0; i < k; i++) {
2932                  checkIncomplete(f);
2933                  checkIncomplete(CompletableFuture.allOf(fs));
2934                  fs[i].complete(one);
# Line 2939 | Line 2939 | public class CompletableFutureTest exten
2939      }
2940  
2941      public void testAllOf_backwards() throws Exception {
2942 <        for (int k = 1; k < 20; ++k) {
2942 >        for (int k = 1; k < 20; k++) {
2943              CompletableFuture<Integer>[] fs
2944                  = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2945 <            for (int i = 0; i < k; ++i)
2945 >            for (int i = 0; i < k; i++)
2946                  fs[i] = new CompletableFuture<>();
2947              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2948              for (int i = k - 1; i >= 0; i--) {
# Line 2959 | Line 2959 | public class CompletableFutureTest exten
2959       * anyOf(no component futures) returns an incomplete future
2960       */
2961      public void testAnyOf_empty() throws Exception {
2962 +        for (Integer v1 : new Integer[] { 1, null })
2963 +    {
2964          CompletableFuture<Object> f = CompletableFuture.anyOf();
2965          checkIncomplete(f);
2966 <    }
2966 >
2967 >        f.complete(v1);
2968 >        checkCompletedNormally(f, v1);
2969 >    }}
2970  
2971      /**
2972       * anyOf returns a future completed normally with a value when
2973       * a component future does
2974       */
2975      public void testAnyOf_normal() throws Exception {
2976 <        for (int k = 0; k < 10; ++k) {
2976 >        for (int k = 0; k < 10; k++) {
2977              CompletableFuture[] fs = new CompletableFuture[k];
2978 <            for (int i = 0; i < k; ++i)
2978 >            for (int i = 0; i < k; i++)
2979                  fs[i] = new CompletableFuture<>();
2980              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
2981              checkIncomplete(f);
2982 <            for (int i = 0; i < k; ++i) {
2983 <                fs[i].complete(one);
2984 <                checkCompletedNormally(f, one);
2985 <                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
2982 >            for (int i = 0; i < k; i++) {
2983 >                fs[i].complete(i);
2984 >                checkCompletedNormally(f, 0);
2985 >                int x = (int) CompletableFuture.anyOf(fs).join();
2986 >                assertTrue(0 <= x && x <= i);
2987 >            }
2988 >        }
2989 >    }
2990 >    public void testAnyOf_normal_backwards() throws Exception {
2991 >        for (int k = 0; k < 10; k++) {
2992 >            CompletableFuture[] fs = new CompletableFuture[k];
2993 >            for (int i = 0; i < k; i++)
2994 >                fs[i] = new CompletableFuture<>();
2995 >            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
2996 >            checkIncomplete(f);
2997 >            for (int i = k - 1; i >= 0; i--) {
2998 >                fs[i].complete(i);
2999 >                checkCompletedNormally(f, k - 1);
3000 >                int x = (int) CompletableFuture.anyOf(fs).join();
3001 >                assertTrue(i <= x && x <= k - 1);
3002              }
3003          }
3004      }
# Line 2986 | Line 3007 | public class CompletableFutureTest exten
3007       * anyOf result completes exceptionally when any component does.
3008       */
3009      public void testAnyOf_exceptional() throws Exception {
3010 <        for (int k = 0; k < 10; ++k) {
3010 >        for (int k = 0; k < 10; k++) {
3011              CompletableFuture[] fs = new CompletableFuture[k];
3012 <            for (int i = 0; i < k; ++i)
3012 >            for (int i = 0; i < k; i++)
3013                  fs[i] = new CompletableFuture<>();
3014              CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
3015              checkIncomplete(f);
3016 <            for (int i = 0; i < k; ++i) {
3016 >            for (int i = 0; i < k; i++) {
3017                  fs[i].completeExceptionally(new CFException());
3018                  checkCompletedWithWrappedCFException(f);
3019                  checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
# Line 3133 | Line 3154 | public class CompletableFutureTest exten
3154          if (!testImplementationDetails) return;
3155          for (ExecutionMode m : ExecutionMode.values())
3156      {
3157 <        final CompletableFuture<Void> f = new CompletableFuture<>();
3158 <        CFException ex = new CFException();
3159 <        f.completeExceptionally(ex);
3160 <        final CompletableFuture<Void> g = f.thenRun(new Noop(m));
3161 <        checkCompletedWithWrappedException(g, ex);
3162 <        final CompletableFuture<Void> h = g.thenRun(new Noop(m));
3163 <        checkCompletedWithWrappedException(h, ex);
3164 <        assertSame(resultOf(g), resultOf(h));
3165 <    }}
3157 >        final CFException ex = new CFException();
3158 >        final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
3159 >        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3160 >
3161 >        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> dependentFactories
3162 >            = new ArrayList<>();
3163 >
3164 >        dependentFactories.add((y) -> m.thenRun(y, new Noop(m)));
3165 >        dependentFactories.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
3166 >        dependentFactories.add((y) -> m.thenApply(y, new IncFunction(m)));
3167 >
3168 >        dependentFactories.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
3169 >        dependentFactories.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
3170 >        dependentFactories.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
3171 >
3172 >        dependentFactories.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
3173 >        dependentFactories.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3174 >        dependentFactories.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3175 >
3176 >        dependentFactories.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
3177 >
3178 >        dependentFactories.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3179 >
3180 >        dependentFactories.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
3181 >        dependentFactories.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
3182 >
3183 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3184 >                 dependentFactory : dependentFactories) {
3185 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3186 >            f.completeExceptionally(ex);
3187 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3188 >            checkCompletedWithWrappedException(src, ex);
3189 >            CompletableFuture<?> dep = dependentFactory.apply(src);
3190 >            checkCompletedWithWrappedException(dep, ex);
3191 >            assertSame(resultOf(src), resultOf(dep));
3192 >        }
3193 >
3194 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3195 >                 dependentFactory : dependentFactories) {
3196 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3197 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3198 >            CompletableFuture<?> dep = dependentFactory.apply(src);
3199 >            f.completeExceptionally(ex);
3200 >            checkCompletedWithWrappedException(src, ex);
3201 >            checkCompletedWithWrappedException(dep, ex);
3202 >            assertSame(resultOf(src), resultOf(dep));
3203 >        }
3204 >
3205 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3206 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3207 >                 dependentFactory : dependentFactories) {
3208 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3209 >            f.cancel(mayInterruptIfRunning);
3210 >            checkCancelled(f);
3211 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3212 >            checkCompletedWithWrappedCancellationException(src);
3213 >            CompletableFuture<?> dep = dependentFactory.apply(src);
3214 >            checkCompletedWithWrappedCancellationException(dep);
3215 >            assertSame(resultOf(src), resultOf(dep));
3216 >        }
3217  
3218 < //     public void testRunAfterEither_resultDeterminedAtTimeOfCreation() {
3219 < //         for (ExecutionMode m : ExecutionMode.values())
3220 < //         for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3221 < //         for (Integer v1 : new Integer[] { 1, null })
3222 < //     {
3223 < //         final CompletableFuture<Integer> f = new CompletableFuture<>();
3224 < //         final CompletableFuture<Integer> g = new CompletableFuture<>();
3225 < //         final Noop[] rs = new Noop[2];
3226 < //         for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
3227 < //         f.complete(v1);
3228 < //         final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
3229 < //         final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
3230 < //         assertTrue(g.cancel(mayInterruptIfRunning));
3159 < //         checkCompletedNormally(h0, null);
3160 < //         checkCompletedNormally(h1, null);
3161 < //         for (Noop r : rs) r.assertInvoked();
3162 < //     }}
3218 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3219 >        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3220 >                 dependentFactory : dependentFactories) {
3221 >            CompletableFuture<Integer> f = new CompletableFuture<>();
3222 >            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
3223 >            CompletableFuture<?> dep = dependentFactory.apply(src);
3224 >            f.cancel(mayInterruptIfRunning);
3225 >            checkCancelled(f);
3226 >            checkCompletedWithWrappedCancellationException(src);
3227 >            checkCompletedWithWrappedCancellationException(dep);
3228 >            assertSame(resultOf(src), resultOf(dep));
3229 >        }
3230 >    }}
3231  
3232   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines