private Queue<Integer> emptyOneQueue() { return Queues.<Integer>one().get(); }
private Queue<Integer> oneQueueWithTestElement(int element) { Queue<Integer> q = Queues.<Integer>one().get(); q.add(element); return q; } }
/** * Transform the item emitted by this {@link Mono} into {@link Iterable}, then forward * its elements into the returned {@link Flux}. The prefetch argument allows to * give an arbitrary prefetch size to the inner {@link Iterable}. * * <p> * <img class="marble" src="doc-files/marbles/flatMapIterableForMono.svg" alt=""> * * @param mapper the {@link Function} to transform input item into a sequence {@link Iterable} * @param <R> the merged output sequence type * * @return a merged {@link Flux} * */ public final <R> Flux<R> flatMapIterable(Function<? super T, ? extends Iterable<? extends R>> mapper) { return Flux.onAssembly(new MonoFlattenIterable<>(this, mapper, Integer .MAX_VALUE, Queues.one())); }
@Test public void capacityOneQueue() { Queue q = Queues.one().get(); assertThat(Queues.capacity(q)).isEqualTo(1); }
@Test public void scanSubscriberLargePrefetchIsLimitedToIntMax() { BlockingIterable.SubscriberIterator<String> subscriberIterator = new BlockingIterable.SubscriberIterator<>(Queues.<String>one().get(), Integer.MAX_VALUE); assertThat(subscriberIterator.scan(Attr.PREFETCH)).isEqualTo(Integer.MAX_VALUE); //FIXME }
@Test public void scanOperatorLargePrefetchIsLimitedToIntMax() { Flux<Integer> source = Flux.range(1, 10); BlockingIterable<Integer> test = new BlockingIterable<>(source, Integer.MAX_VALUE, Queues.one()); assertThat(test.scan(Attr.PREFETCH)).isEqualTo(Integer.MAX_VALUE); }
@Test public void scanSubscriberTerminated() { BlockingIterable.SubscriberIterator<String> test = new BlockingIterable.SubscriberIterator<>(Queues.<String>one().get(), 123); assertThat(test.scan(Scannable.Attr.TERMINATED)).describedAs("before TERMINATED").isFalse(); test.onComplete(); assertThat(test.scan(Scannable.Attr.TERMINATED)).describedAs("after TERMINATED").isTrue(); }
@Test public void scanMain() { CoreSubscriber<Integer> actual = new LambdaSubscriber<>(null, e -> {}, null, null); FluxCombineLatest.CombineLatestCoordinator<String, Integer> test = new FluxCombineLatest.CombineLatestCoordinator<>( actual, arr -> { throw new IllegalStateException("boomArray");}, 123, Queues.<FluxCombineLatest.SourceAndArray>one().get(), 456); test.request(2L); test.error = new IllegalStateException("boom"); //most straightforward way to set it as otherwise it is drained assertThat(test.scan(Scannable.Attr.REQUESTED_FROM_DOWNSTREAM)).isEqualTo(2L); assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(actual); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); assertThat(test.scan(Scannable.Attr.ERROR)).isSameAs(test.error); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); test.innerComplete(1); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); }
@Test public void scanConcatMapImmediateError() { CoreSubscriber<Integer> actual = new LambdaSubscriber<>(null, e -> {}, null, null); FluxConcatMap.ConcatMapImmediate<String, Integer> test = new FluxConcatMap.ConcatMapImmediate<>( actual, s -> Mono.just(s.length()), Queues.one(), 123); Subscription parent = Operators.emptySubscription(); test.onSubscribe(parent); assertThat(test.scan(Scannable.Attr.DELAY_ERROR)).isFalse(); //note that most of the time, the error will be hidden by TERMINATED as soon as it has been propagated downstream :( test.error = new IllegalStateException("boom"); assertThat(test.scan(Scannable.Attr.ERROR)).hasMessage("boom"); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); test.onError(new IllegalStateException("boom2")); assertThat(test.scan(Scannable.Attr.ERROR)).isSameAs(Exceptions.TERMINATED); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); }
@Test public void scanSubscriberCancelled() { BlockingIterable.SubscriberIterator<String> test = new BlockingIterable.SubscriberIterator<>( Queues.<String>one().get(), 123); //simulate cancellation by offering two elements test.onNext("a"); assertThat(test.scan(Scannable.Attr.CANCELLED)).describedAs("before CANCELLED").isFalse(); test.onNext("b"); assertThat(test.scan(Scannable.Attr.CANCELLED)).describedAs("after CANCELLED").isTrue(); }
@Test public void scanOperator() { Flux<Integer> source = Flux.range(1, 10).map(i -> i - 1); FluxFlattenIterable<Integer, Integer> test = new FluxFlattenIterable<>(source, i -> new ArrayList<>(i), 35, Queues.one()); assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(source); assertThat(test.scan(Attr.PREFETCH)).isEqualTo(35); }
@Test public void scanConcatMapImmediate() { CoreSubscriber<Integer> actual = new LambdaSubscriber<>(null, e -> {}, null, null); FluxConcatMap.ConcatMapImmediate<String, Integer> test = new FluxConcatMap.ConcatMapImmediate<>( actual, s -> Mono.just(s.length()), Queues.one(), 123); Subscription parent = Operators.emptySubscription(); test.onSubscribe(parent); test.queue.offer("foo"); assertThat(test.scan(Scannable.Attr.BUFFERED)).isEqualTo(1); assertThat(test.scan(Scannable.Attr.PREFETCH)).isEqualTo(123); assertThat(test.scan(Scannable.Attr.DELAY_ERROR)).isFalse(); assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(parent); assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(actual); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); test.onComplete(); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); test.cancelled = true; assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue(); }
@Test public void scanOperator() { ParallelSource<Integer> source = new ParallelSource<>(Flux.just(500, 300), 10, 123, Queues.one()); ParallelPeek<Integer> test = new ParallelPeek<>(source, null, null, null, null, null, null, null, null); assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(source); assertThat(test.scan(Scannable.Attr.PREFETCH)) .isEqualTo(source.getPrefetch()) .isEqualTo(test.getPrefetch()) .isEqualTo(123); }
@Test public void scanOperator() { Flux<Integer> source = Flux.range(1, 10); BlockingIterable<Integer> test = new BlockingIterable<>(source, 35, Queues.one()); assertThat(test.scanUnsafe(Scannable.Attr.PARENT)).describedAs("PARENT").isSameAs(source); //type safe attributes assertThat(test.scanUnsafe(Attr.PREFETCH)).describedAs("PREFETCH unsafe").isEqualTo(35); assertThat(test.scan(Attr.PREFETCH)).describedAs("PREFETCH").isEqualTo(35); //FIXME }
@Test public void scanOperator() { ParallelFlux<Integer> source = Flux.just(500, 300).parallel(10); ParallelMergeSequential<Integer> test = new ParallelMergeSequential<>(source, 123, Queues.one()); assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(source); assertThat(test.scan(Scannable.Attr.PREFETCH)).isEqualTo(123); }
@Test public void scanSubscriberError() { BlockingIterable.SubscriberIterator<String> test = new BlockingIterable.SubscriberIterator<>( Queues.<String>one().get(), 123); IllegalStateException error = new IllegalStateException("boom"); assertThat(test.scan(Scannable.Attr.ERROR)).describedAs("before ERROR") .isNull(); test.onError(error); assertThat(test.scan(Scannable.Attr.ERROR)).describedAs("after ERROR") .isSameAs(error); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); }
@Test public void scanLeftRightEndSubscriber() { CoreSubscriber<String> actual = new LambdaSubscriber<>(null, e -> {}, null, sub -> sub.request(100)); FluxGroupJoin.GroupJoinSubscription<String, String, String, String, String> parent = new FluxGroupJoin.GroupJoinSubscription<>(actual, s -> Mono.just(s), s -> Mono.just(s), (l, r) -> l, Queues.one()); FluxGroupJoin.LeftRightEndSubscriber test = new FluxGroupJoin.LeftRightEndSubscriber(parent, false, 1); Subscription sub = Operators.emptySubscription(); test.onSubscribe(sub); assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(sub); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); test.dispose(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue(); } }
@Test public void scanInner() { CoreSubscriber<Integer> actual = new LambdaSubscriber<>(null, e -> {}, null, null); FluxCombineLatest.CombineLatestCoordinator<String, Integer> main = new FluxCombineLatest.CombineLatestCoordinator<>( actual, arr -> arr.length, 123, Queues.<FluxCombineLatest.SourceAndArray>one().get(), 456); FluxCombineLatest.CombineLatestInner<String> test = new FluxCombineLatest.CombineLatestInner<>(main, 1, 789); Subscription parent = Operators.emptySubscription(); test.onSubscribe(parent); assertThat(test.scan(Scannable.Attr.PREFETCH)).isEqualTo(789); assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(parent); assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(main); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); test.cancel(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue(); }
@Test public void scanSubscriber() { BlockingIterable.SubscriberIterator<String> subscriberIterator = new BlockingIterable.SubscriberIterator<>(Queues.<String>one().get(), 123); Subscription s = Operators.emptySubscription(); subscriberIterator.onSubscribe(s); assertThat(subscriberIterator.scan(Scannable.Attr.PARENT)).describedAs("PARENT") .isSameAs(s); assertThat(subscriberIterator.scan(Scannable.Attr.TERMINATED)).describedAs("TERMINATED").isFalse(); assertThat(subscriberIterator.scan(Scannable.Attr.CANCELLED)).describedAs("CANCELLED").isFalse(); assertThat(subscriberIterator.scan(Scannable.Attr.ERROR)).describedAs("ERROR").isNull(); assertThat(subscriberIterator.scan(Attr.PREFETCH)).describedAs("PREFETCH").isEqualTo(123); //FIXME }
@Test public void scanInnerSubscriber() { @SuppressWarnings("unchecked") CoreSubscriber<String>[] subs = new CoreSubscriber[2]; subs[0] = new LambdaSubscriber<>(null, e -> {}, null, null); subs[1] = new LambdaSubscriber<>(null, e -> {}, null, null); ParallelSource.ParallelSourceMain<String> main = new ParallelSource.ParallelSourceMain<>( subs, 123, Queues.one()); ParallelSource.ParallelSourceMain.ParallelSourceInner<String> test = new ParallelSource.ParallelSourceMain.ParallelSourceInner<>( main, 1, 10); assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(main); assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(subs[test.index]); }