Examples with CoreSubscriber reactor.core.CoreSubscriber used on opensource projects

Example 1 with CoreSubscriber

use of reactor.core.CoreSubscriber in project reactor-core by reactor.

the class DefaultTestPublisherTests method normalIgnoresMultipleTerminations.

@Test
public void normalIgnoresMultipleTerminations() {
    TestPublisher<String> publisher = TestPublisher.create();
    AtomicLong count = new AtomicLong();
    Subscriber<String> subscriber = new CoreSubscriber<String>() {

        @Override
        public void onSubscribe(Subscription s) {
        }

        @Override
        public void onNext(String s) {
        }

        @Override
        public void onError(Throwable t) {
            count.incrementAndGet();
        }

        @Override
        public void onComplete() {
            count.incrementAndGet();
        }
    };
    publisher.subscribe(subscriber);
    publisher.complete().emit("A", "B", "C").error(new IllegalStateException("boom"));
    assertThat(count.get()).isEqualTo(1);
}

Example 2 with CoreSubscriber

use of reactor.core.CoreSubscriber in project reactor-core by reactor.

the class ParallelSourceTest method scanMainSubscriber.

@Test
public void scanMainSubscriber() {
    @SuppressWarnings("unchecked") CoreSubscriber<String>[] subs = new CoreSubscriber[1];
    subs[0] = new LambdaSubscriber<>(null, e -> {
    }, null, null);
    ParallelSource.ParallelSourceMain<String> test = new ParallelSource.ParallelSourceMain<>(subs, 123, Queues.one());
    Subscription parent = Operators.emptySubscription();
    test.onSubscribe(parent);
    assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(parent);
    assertThat(test.scan(Scannable.Attr.PREFETCH)).isEqualTo(123);
    assertThat(test.scan(Scannable.Attr.BUFFERED)).isZero();
    test.queue.offer("foo");
    assertThat(test.scan(Scannable.Attr.BUFFERED)).isEqualTo(1);
    assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse();
    assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();
    assertThat(test.scan(Scannable.Attr.ERROR)).isNull();
    test.onError(new IllegalStateException("boom"));
    assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue();
    assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();
    assertThat(test.scan(Scannable.Attr.ERROR)).hasMessage("boom");
    test.cancel();
    assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue();
}

Example 3 with CoreSubscriber

use of reactor.core.CoreSubscriber in project reactor-core by reactor.

the class FluxGroupByTest method twoGroupsConsumeWithSubscribePrefetchSmaller.

@Test
public void twoGroupsConsumeWithSubscribePrefetchSmaller() {
    ForkJoinPool forkJoinPool = new ForkJoinPool();
    AssertSubscriber<Integer> ts1 = AssertSubscriber.create();
    AssertSubscriber<Integer> ts2 = AssertSubscriber.create();
    AssertSubscriber<Integer> ts3 = AssertSubscriber.create();
    ts3.onSubscribe(Operators.emptySubscription());
    Flux.range(0, 1_000_000).groupBy(v -> v & 1).subscribe(new CoreSubscriber<GroupedFlux<Integer, Integer>>() {

        @Override
        public void onSubscribe(Subscription s) {
            s.request(Long.MAX_VALUE);
        }

        @Override
        public void onNext(GroupedFlux<Integer, Integer> t) {
            if (t.key() == 0) {
                t.publishOn(Schedulers.fromExecutorService(forkJoinPool), 32).subscribe(ts1);
            } else {
                t.publishOn(Schedulers.fromExecutorService(forkJoinPool), 32).subscribe(ts2);
            }
        }

        @Override
        public void onError(Throwable t) {
            ts3.onError(t);
        }

        @Override
        public void onComplete() {
            ts3.onComplete();
        }
    });
    if (!ts1.await(Duration.ofSeconds(5)).isTerminated()) {
        Assert.fail("main subscriber timed out");
    }
    if (!ts2.await(Duration.ofSeconds(5)).isTerminated()) {
        Assert.fail("group 0 subscriber timed out");
    }
    if (!ts3.await(Duration.ofSeconds(5)).isTerminated()) {
        Assert.fail("group 1 subscriber timed out");
    }
    ts1.assertValueCount(500_000).assertNoError().assertComplete();
    ts2.assertValueCount(500_000).assertNoError().assertComplete();
    ts3.assertNoValues().assertNoError().assertComplete();
}

Example 4 with CoreSubscriber

use of reactor.core.CoreSubscriber in project reactor-core by reactor.

the class FluxGroupByTest method twoGroupsConsumeWithSubscribePrefetchBigger.

@Test
public void twoGroupsConsumeWithSubscribePrefetchBigger() {
    ForkJoinPool forkJoinPool = new ForkJoinPool();
    AssertSubscriber<Integer> ts1 = AssertSubscriber.create();
    AssertSubscriber<Integer> ts2 = AssertSubscriber.create();
    AssertSubscriber<Integer> ts3 = AssertSubscriber.create();
    ts3.onSubscribe(Operators.emptySubscription());
    Flux.range(0, 1_000_000).groupBy(v -> v & 1).subscribe(new CoreSubscriber<GroupedFlux<Integer, Integer>>() {

        @Override
        public void onSubscribe(Subscription s) {
            s.request(Long.MAX_VALUE);
        }

        @Override
        public void onNext(GroupedFlux<Integer, Integer> t) {
            if (t.key() == 0) {
                t.publishOn(Schedulers.fromExecutorService(forkJoinPool), 1024).subscribe(ts1);
            } else {
                t.publishOn(Schedulers.fromExecutorService(forkJoinPool), 1024).subscribe(ts2);
            }
        }

        @Override
        public void onError(Throwable t) {
            ts3.onError(t);
        }

        @Override
        public void onComplete() {
            ts3.onComplete();
        }
    });
    if (!ts1.await(Duration.ofSeconds(5)).isTerminated()) {
        Assert.fail("main subscriber timed out");
    }
    if (!ts2.await(Duration.ofSeconds(5)).isTerminated()) {
        Assert.fail("group 0 subscriber timed out");
    }
    if (!ts3.await(Duration.ofSeconds(5)).isTerminated()) {
        Assert.fail("group 1 subscriber timed out");
    }
    ts1.assertValueCount(500_000).assertNoError().assertComplete();
    ts2.assertValueCount(500_000).assertNoError().assertComplete();
    ts3.assertNoValues().assertNoError().assertComplete();
}

Example 5 with CoreSubscriber

use of reactor.core.CoreSubscriber in project reactor-core by reactor.

the class FluxGroupByTest method twoGroupsFullAsyncFullHide.

@Test
@Ignore("temporarily disabled, see gh-1028")
public void twoGroupsFullAsyncFullHide() {
    ForkJoinPool forkJoinPool = new ForkJoinPool();
    AssertSubscriber<Integer> ts1 = AssertSubscriber.create();
    AssertSubscriber<Integer> ts2 = AssertSubscriber.create();
    AssertSubscriber<Integer> ts3 = AssertSubscriber.create();
    ts3.onSubscribe(Operators.emptySubscription());
    Flux.range(0, 1_000_000).hide().publishOn(Schedulers.fromExecutorService(forkJoinPool)).groupBy(v -> v & 1).subscribe(new CoreSubscriber<GroupedFlux<Integer, Integer>>() {

        @Override
        public void onSubscribe(Subscription s) {
            s.request(Long.MAX_VALUE);
        }

        @Override
        public void onNext(GroupedFlux<Integer, Integer> t) {
            if (t.key() == 0) {
                t.hide().publishOn(Schedulers.fromExecutorService(forkJoinPool)).subscribe(ts1);
            } else {
                t.hide().publishOn(Schedulers.fromExecutorService(forkJoinPool)).subscribe(ts2);
            }
        }

        @Override
        public void onError(Throwable t) {
            ts3.onError(t);
        }

        @Override
        public void onComplete() {
            ts3.onComplete();
        }
    });
    ts1.await(Duration.ofSeconds(5));
    ts2.await(Duration.ofSeconds(5));
    ts3.await(Duration.ofSeconds(5));
    ts1.assertValueCount(500_000).assertNoError().assertComplete();
    ts2.assertValueCount(500_000).assertNoError().assertComplete();
    ts3.assertNoValues().assertNoError().assertComplete();
}