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.37 by jsr166, Sun Jun 1 23:20:19 2014 UTC vs.
Revision 1.38 by jsr166, Sun Jun 1 23:51:44 2014 UTC

# Line 318 | Line 318 | public class CompletableFutureTest exten
318  
319      // Choose non-commutative actions for better coverage
320  
321 <    // A non-commutative function that handles null values as well,
322 <    // and produces null values occasionally.
323 <    public static Integer subtract(Integer x, Integer y) {
321 >    // A non-commutative function that handles and produces null values as well.
322 >    static Integer subtract(Integer x, Integer y) {
323          return (x == null && y == null) ? null :
324              ((x == null) ? 42 : x.intValue())
325              - ((y == null) ? 99 : y.intValue());
326      }
327  
328 +    // A function that handles and produces null values as well.
329 +    static Integer inc(Integer x) {
330 +        return (x == null) ? null : x + 1;
331 +    }
332 +
333      static final Supplier<Integer> supplyOne =
334          () -> Integer.valueOf(1);
335      static final Function<Integer, Integer> inc =
# Line 333 | Line 337 | public class CompletableFutureTest exten
337      static final BiFunction<Integer, Integer, Integer> subtract =
338          (Integer x, Integer y) -> subtract(x, y);
339      static final class IncAction implements Consumer<Integer> {
340 <        int value;
341 <        public void accept(Integer x) { value = x.intValue() + 1; }
340 >        int invocationCount = 0;
341 >        Integer value;
342 >        public boolean ran() { return invocationCount == 1; }
343 >        public void accept(Integer x) {
344 >            invocationCount++;
345 >            value = inc(x);
346 >        }
347 >    }
348 >    static final class IncFunction implements Function<Integer,Integer> {
349 >        int invocationCount = 0;
350 >        Integer value;
351 >        public boolean ran() { return invocationCount == 1; }
352 >        public Integer apply(Integer x) {
353 >            invocationCount++;
354 >            return value = inc(x);
355 >        }
356      }
357      static final class SubtractAction implements BiConsumer<Integer, Integer> {
358          int invocationCount = 0;
# Line 449 | Line 467 | public class CompletableFutureTest exten
467                   BiFunction<? super T,? super U,? extends V> a) {
468                  return f.thenCombine(g, a);
469              }
470 +            public <T,U> CompletableFuture<U> applyToEither
471 +                (CompletableFuture<T> f,
472 +                 CompletionStage<? extends T> g,
473 +                 Function<? super T,U> a) {
474 +                return f.applyToEither(g, a);
475 +            }
476 +            public <T> CompletableFuture<Void> acceptEither
477 +                (CompletableFuture<T> f,
478 +                 CompletionStage<? extends T> g,
479 +                 Consumer<? super T> a) {
480 +                return f.acceptEither(g, a);
481 +            }
482 +            public <T> CompletableFuture<Void> runAfterEither
483 +                (CompletableFuture<T> f,
484 +                 CompletionStage<?> g,
485 +                 java.lang.Runnable a) {
486 +                return f.runAfterEither(g, a);
487 +            }
488 +            public <T,U> CompletableFuture<U> thenCompose
489 +                (CompletableFuture<T> f,
490 +                 Function<? super T,? extends CompletionStage<U>> a) {
491 +                return f.thenCompose(a);
492 +            }
493 +            public <T> CompletableFuture<T> whenComplete
494 +                (CompletableFuture<T> f,
495 +                 BiConsumer<? super T,? super Throwable> a) {
496 +                return f.whenComplete(a);
497 +            }
498          },
499  
500   //             /** Experimental way to do more testing */
# Line 482 | Line 528 | public class CompletableFutureTest exten
528                   BiFunction<? super T,? super U,? extends V> a) {
529                  return f.thenCombineAsync(g, a);
530              }
531 +            public <T,U> CompletableFuture<U> applyToEither
532 +                (CompletableFuture<T> f,
533 +                 CompletionStage<? extends T> g,
534 +                 Function<? super T,U> a) {
535 +                return f.applyToEitherAsync(g, a);
536 +            }
537 +            public <T> CompletableFuture<Void> acceptEither
538 +                (CompletableFuture<T> f,
539 +                 CompletionStage<? extends T> g,
540 +                 Consumer<? super T> a) {
541 +                return f.acceptEitherAsync(g, a);
542 +            }
543 +            public <T> CompletableFuture<Void> runAfterEither
544 +                (CompletableFuture<T> f,
545 +                 CompletionStage<?> g,
546 +                 java.lang.Runnable a) {
547 +                return f.runAfterEitherAsync(g, a);
548 +            }
549 +            public <T,U> CompletableFuture<U> thenCompose
550 +                (CompletableFuture<T> f,
551 +                 Function<? super T,? extends CompletionStage<U>> a) {
552 +                return f.thenComposeAsync(a);
553 +            }
554 +            public <T> CompletableFuture<T> whenComplete
555 +                (CompletableFuture<T> f,
556 +                 BiConsumer<? super T,? super Throwable> a) {
557 +                return f.whenCompleteAsync(a);
558 +            }
559          },
560  
561   //         REVERSE_DEFAULT_ASYNC {
# Line 514 | Line 588 | public class CompletableFutureTest exten
588                   BiFunction<? super T,? super U,? extends V> a) {
589                  return f.thenCombineAsync(g, a, new ThreadExecutor());
590              }
591 +            public <T,U> CompletableFuture<U> applyToEither
592 +                (CompletableFuture<T> f,
593 +                 CompletionStage<? extends T> g,
594 +                 Function<? super T,U> a) {
595 +                return f.applyToEitherAsync(g, a, new ThreadExecutor());
596 +            }
597 +            public <T> CompletableFuture<Void> acceptEither
598 +                (CompletableFuture<T> f,
599 +                 CompletionStage<? extends T> g,
600 +                 Consumer<? super T> a) {
601 +                return f.acceptEitherAsync(g, a, new ThreadExecutor());
602 +            }
603 +            public <T> CompletableFuture<Void> runAfterEither
604 +                (CompletableFuture<T> f,
605 +                 CompletionStage<?> g,
606 +                 java.lang.Runnable a) {
607 +                return f.runAfterEitherAsync(g, a, new ThreadExecutor());
608 +            }
609 +            public <T,U> CompletableFuture<U> thenCompose
610 +                (CompletableFuture<T> f,
611 +                 Function<? super T,? extends CompletionStage<U>> a) {
612 +                return f.thenComposeAsync(a, new ThreadExecutor());
613 +            }
614 +            public <T> CompletableFuture<T> whenComplete
615 +                (CompletableFuture<T> f,
616 +                 BiConsumer<? super T,? super Throwable> a) {
617 +                return f.whenCompleteAsync(a, new ThreadExecutor());
618 +            }
619          };
620  
621          public abstract <T,U> CompletableFuture<Void> runAfterBoth
# Line 526 | Line 628 | public class CompletableFutureTest exten
628              (CompletableFuture<T> f,
629               CompletionStage<? extends U> g,
630               BiFunction<? super T,? super U,? extends V> a);
631 +        public abstract <T,U> CompletableFuture<U> applyToEither
632 +            (CompletableFuture<T> f,
633 +             CompletionStage<? extends T> g,
634 +             Function<? super T,U> a);
635 +        public abstract <T> CompletableFuture<Void> acceptEither
636 +            (CompletableFuture<T> f,
637 +             CompletionStage<? extends T> g,
638 +             Consumer<? super T> a);
639 +        public abstract <T> CompletableFuture<Void> runAfterEither
640 +            (CompletableFuture<T> f,
641 +             CompletionStage<?> g,
642 +             java.lang.Runnable a);
643 +        public abstract <T,U> CompletableFuture<U> thenCompose
644 +            (CompletableFuture<T> f,
645 +             Function<? super T,? extends CompletionStage<U>> a);
646 +        public abstract <T> CompletableFuture<T> whenComplete
647 +            (CompletableFuture<T> f,
648 +             BiConsumer<? super T,? super Throwable> a);
649 +
650 +
651      }
652  
653      /**
# Line 778 | Line 900 | public class CompletableFutureTest exten
900          CompletableFuture<Void> g = f.thenAccept(r);
901          f.complete(one);
902          checkCompletedNormally(g, null);
903 <        assertEquals(r.value, 2);
903 >        assertEquals(r.value, (Integer) 2);
904      }
905  
906      /**
# Line 1797 | Line 1919 | public class CompletableFutureTest exten
1919          checkCompletedNormally(g, null);
1920          f2.complete(one);
1921          checkCompletedNormally(g, null);
1922 <        assertEquals(r.value, 2);
1922 >        assertEquals(r.value, (Integer) 2);
1923  
1924          r = new IncAction();
1925          f = new CompletableFuture<>();
# Line 1805 | Line 1927 | public class CompletableFutureTest exten
1927          f2 = new CompletableFuture<>();
1928          g = f.acceptEither(f2, r);
1929          checkCompletedNormally(g, null);
1930 <        assertEquals(r.value, 2);
1930 >        assertEquals(r.value, (Integer) 2);
1931      }
1932  
1933      /**
# Line 2115 | Line 2237 | public class CompletableFutureTest exten
2237          CompletableFuture<Void> g = f.thenAcceptAsync(r);
2238          f.complete(one);
2239          checkCompletedNormally(g, null);
2240 <        assertEquals(r.value, 2);
2240 >        assertEquals(r.value, (Integer) 2);
2241      }
2242  
2243      /**
# Line 2229 | Line 2351 | public class CompletableFutureTest exten
2351          CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2352          f.complete(one);
2353          checkCompletedNormally(g, null);
2354 <        assertEquals(r.value, 2);
2354 >        assertEquals(r.value, (Integer) 2);
2355  
2356          r = new IncAction();
2357          f = new CompletableFuture<>();
# Line 2237 | Line 2359 | public class CompletableFutureTest exten
2359          f2 = new CompletableFuture<>();
2360          g = f.acceptEitherAsync(f2, r);
2361          checkCompletedNormally(g, null);
2362 <        assertEquals(r.value, 2);
2362 >        assertEquals(r.value, (Integer) 2);
2363      }
2364  
2365      /**
# Line 2554 | Line 2676 | public class CompletableFutureTest exten
2676          CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2677          f.complete(one);
2678          checkCompletedNormally(g, null);
2679 <        assertEquals(r.value, 2);
2679 >        assertEquals(r.value, (Integer) 2);
2680      }
2681  
2682      /**
# Line 2668 | Line 2790 | public class CompletableFutureTest exten
2790          CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2791          f.complete(one);
2792          checkCompletedNormally(g, null);
2793 <        assertEquals(r.value, 2);
2793 >        assertEquals(r.value, (Integer) 2);
2794  
2795          r = new IncAction();
2796          f = new CompletableFuture<>();
# Line 2676 | Line 2798 | public class CompletableFutureTest exten
2798          f2 = new CompletableFuture<>();
2799          g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2800          checkCompletedNormally(g, null);
2801 <        assertEquals(r.value, 2);
2801 >        assertEquals(r.value, (Integer) 2);
2802      }
2803  
2804      /**

Diff Legend

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