@Override public void onComplete() { signalCached(Signal.complete()); }
@Override public void onComplete() { if (establishedFusionMode != Fuseable.ASYNC) { onExpectation(Signal.complete()); this.completeLatch.countDown(); } else { done = true; serializeDrainAndSubscriptionEvent(); } }
@Override public void onComplete() { if(terminalSignal != null){ return; } terminalSignal = Signal.complete(this.cachedContext); long p = produced; if (p != 0L) { Operators.addCap(REQUESTED, this, -p); } DrainUtils.postComplete(actual, this, REQUESTED, this, this); }
@Override public void onComplete() { if (done) { return; } done = true; try { onSignal.accept(Signal.complete(cachedContext)); } catch (Throwable e) { done = false; onError(Operators.onOperatorError(s, e, cachedContext)); return; } actual.onComplete(); }
@Test public void shouldReturnNormallyIfExceptionIsThrownOnCompleteDuringSwitching() { Signal<? extends Long>[] first = new Signal[1]; StepVerifier.create(Flux.<Long>empty() .switchOnFirst((s, f) -> { first[0] = s; throw new NullPointerException(); }) ) .expectSubscription() .expectError(NullPointerException.class) .verifyThenAssertThat() .hasOperatorErrorMatching(t -> { Assertions.assertThat(t) .isInstanceOf(NullPointerException.class); return true; }); Assertions.assertThat(first).containsExactly(Signal.complete()); }
@Test public void singleCompletion() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Mono<Integer> dematerialize = Mono.just(Signal.<Integer>complete()) .dematerialize(); dematerialize.subscribe(ts); ts.assertNoValues() .assertNoError() .assertComplete(); }
@Test public void immediateCompletion() { AssertSubscriber<Integer> ts = AssertSubscriber.create(0); Mono<Integer> dematerialize = Mono.just(Signal.<Integer>complete()) .dematerialize(); dematerialize.subscribe(ts); ts.assertNoValues() .assertNoError() .assertComplete(); }
@Test public void shouldSendOnCompleteSignalWithDelaySubscription() { Signal<? extends Long>[] first = new Signal[1]; StepVerifier.create(Flux.<Long>empty() .switchOnFirst((s, f) -> { first[0] = s; return f.delaySubscription(Duration.ofMillis(100)); })) .expectSubscription() .expectComplete() .verify(); Assertions.assertThat(first).containsExactly(Signal.complete()); }
@Test public void mainErrorWhileIsPropagatedToBothWindowAndMain() { DirectProcessor<Integer> sp1 = DirectProcessor.create(); FluxWindowPredicate<Integer> windowWhile = new FluxWindowPredicate<>( sp1, Queues.small(), Queues.unbounded(), Queues.SMALL_BUFFER_SIZE, i -> i % 3 == 0, Mode.WHILE); StepVerifier.create(windowWhile.flatMap(Flux::materialize)) .expectSubscription() .then(() -> sp1.onNext(1)) .expectNext(Signal.complete()) .then(() -> sp1.onNext(2)) .expectNext(Signal.complete()) .then(() -> sp1.onNext(3)) //at this point, new window, need another data to close it .then(() -> sp1.onNext(4)) .expectNext(Signal.next(3), Signal.complete()) .then(() -> sp1.onError(new RuntimeException("forced failure"))) //this is the error in the main: .expectErrorMessage("forced failure") .verify(Duration.ofMillis(100)); assertThat(sp1.hasDownstreams()).isFalse(); }
@Test public void immediateCompletion() { AssertSubscriber<Integer> ts = AssertSubscriber.create(0); Flux<Integer> dematerialize = Flux.just(Signal.<Integer>complete()).dematerialize(); dematerialize.subscribe(ts); ts.assertNoValues() .assertNoError() .assertComplete(); }
@Test public void singleCompletion() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Flux<Integer> dematerialize = Flux.just(Signal.<Integer>complete()).dematerialize(); dematerialize.subscribe(ts); ts.assertNoValues() .assertNoError() .assertComplete(); }
@Test public void completeOnlyBackpressured() { AssertSubscriber<Signal<Integer>> ts = AssertSubscriber.create(0L); Mono.<Integer>empty().materialize() .subscribe(ts); ts.assertNoValues() .assertNoError() .assertNotComplete(); ts.request(1); ts.assertValues(Signal.complete()) .assertNoError() .assertComplete(); }
@Test public void normalBuffered() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Flux<Integer> source = Flux.<Signal<Integer>>create(e -> { e.next(Signal.next(1)); e.next(Signal.next(2)); e.next(Signal.next(3)); e.next(Signal.complete()); System.out.println(e.isCancelled()); System.out.println(e.requestedFromDownstream()); }).dematerialize(); source.subscribe(ts); ts.assertValues(1, 2, 3) .assertNoError() .assertComplete(); }
@Test public void dematerialize() { StepVerifier.create(Flux.just(Signal.next("Three"), Signal.next("Two"), Signal.next("One"), Signal.complete()) .dematerialize()) .expectNext("Three") .expectNext("Two") .expectNext("One") .verifyComplete(); }
@Test public void completeOnlyBackpressured() { AssertSubscriber<Signal<Integer>> ts = AssertSubscriber.create(0L); Flux.<Integer>empty().materialize() .subscribe(ts); ts.assertNoValues() .assertNoError() .assertNotComplete(); ts.request(1); ts.assertValues(Signal.complete()) .assertNoError() .assertComplete(); }
@Test public void neverEnding() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Flux<Integer> dematerialize = Flux.just(Signal.next(1), Signal.next(2), Signal.next(3), Signal.<Integer>complete()) .concatWith(Flux.never()) .dematerialize(); dematerialize.subscribe(ts); ts.assertValues(1, 2, 3) .assertNoError() .assertComplete(); }
@Test public void completeAfterSingleSignal() { AssertSubscriber<Integer> ts = AssertSubscriber.create(0); Flux<Integer> dematerialize = Flux.just(Signal.next(1), Signal.<Integer>complete()).dematerialize(); dematerialize.subscribe(ts); ts.assertNoValues() .assertNoError() .assertNotComplete(); ts.request(1); ts.assertValues(1) .assertNoError() .assertComplete(); }
@Test public void twoSignalsAndComplete() { AssertSubscriber<Integer> ts = AssertSubscriber.create(0); Flux<Integer> dematerialize = Flux.just(Signal.next(1), Signal.next(2), Signal.<Integer>complete()).dematerialize(); dematerialize.subscribe(ts); ts.assertNoValues() .assertNoError() .assertNotComplete(); ts.request(1); ts.assertValues(1) .assertNoError() .assertNotComplete(); ts.request(1); ts.assertValues(1, 2) .assertNoError() .assertComplete(); }