@Override public void accept(SynchronousSink<LineInfo> sink) { if (this.scanner.hasNext()) { String line = this.scanner.nextLine(); LineInfo current = new LineInfo(line, this.previous); sink.next(current); this.previous = current; } else { sink.complete(); } } }
private Flux<String> chunks1K() { return Flux.generate(sink -> { StringBuilder sb = new StringBuilder(); do { for (char c : "0123456789".toCharArray()) { sb.append(c); if (sb.length() + 1 == 1024) { sink.next(sb.append("\n").toString()); return; } } } while (true); }); }
@Override public void accept(SynchronousSink<DataBuffer> sink) { boolean release = true; DataBuffer dataBuffer = this.dataBufferFactory.allocateBuffer(this.bufferSize); try { int read; ByteBuffer byteBuffer = dataBuffer.asByteBuffer(0, dataBuffer.capacity()); if ((read = this.channel.read(byteBuffer)) >= 0) { dataBuffer.writePosition(read); release = false; sink.next(dataBuffer); } else { sink.complete(); } } catch (IOException ex) { sink.error(ex); } finally { if (release) { release(dataBuffer); } } } }
Flux<String> filterTest2(Flux<String> f) { return f.handle((a, b) -> { b.next(a); if ("test2".equals(a)) { b.complete(); } }); }
@Test public void errorAfterMultipleItems() throws Exception { IllegalStateException error = new IllegalStateException("boo"); Flux<String> publisher = Flux.generate(() -> 0, (idx , subscriber) -> { int i = ++idx; subscriber.next(String.valueOf(i)); if (i == 3) { subscriber.error(error); } return i; }); Mono<Void> completion = publisher.as(this::sendOperator); Signal<Void> signal = completion.materialize().block(); assertNotNull(signal); assertSame("Unexpected signal: " + signal, error, signal.getThrowable()); assertEquals(3, this.writer.items.size()); assertEquals("1", this.writer.items.get(0)); assertEquals("2", this.writer.items.get(1)); assertEquals("3", this.writer.items.get(2)); assertSame(error, this.writer.error); }
@Test public void nextAfterCompleteFused() { StepVerifier.create(Flux.just(1) .handle((v, sink) -> { sink.complete(); sink.next(2); })) .verifyErrorSatisfies(e -> assertThat(e).isInstanceOf(IllegalStateException.class) .hasMessage("Cannot emit after a complete or error")); }
@Test public void nextAfterErrorFusedConditional() { StepVerifier.create(Flux.just(1) .filter(i -> true) .handle((v, sink) -> { sink.error(new NullPointerException("boom")); sink.next(2); })) .verifyErrorSatisfies(e -> assertThat(e).isInstanceOf(IllegalStateException.class) .hasMessage("Cannot emit after a complete or error")); }
@Test public void nextAfterErrorNormal() { StepVerifier.create(Flux.just(1) .hide() .handle((v, sink) -> { sink.error(new NullPointerException("boom")); sink.next(2); })) .verifyErrorSatisfies(e -> assertThat(e).isInstanceOf(IllegalStateException.class) .hasMessage("Cannot emit after a complete or error")); }
@Test public void nextAfterCompleteFusedConditional() { StepVerifier.create(Flux.just(1) .filter(i -> true) .handle((v, sink) -> { sink.complete(); sink.next(2); })) .verifyErrorSatisfies(e -> assertThat(e).isInstanceOf(IllegalStateException.class) .hasMessage("Cannot emit after a complete or error")); }
@Test public void nextAfterErrorNormalConditional() { StepVerifier.create(Flux.just(1) .hide() .filter(i -> true) .handle((v, sink) -> { sink.error(new NullPointerException("boom")); sink.next(2); })) .verifyErrorSatisfies(e -> assertThat(e).isInstanceOf(IllegalStateException.class) .hasMessage("Cannot emit after a complete or error")); }
@Test public void nextAfterCompleteNormalConditional() { StepVerifier.create(Flux.just(1) .hide() .filter(i -> true) .handle((v, sink) -> { sink.complete(); sink.next(2); })) .verifyErrorSatisfies(e -> assertThat(e).isInstanceOf(IllegalStateException.class) .hasMessage("Cannot emit after a complete or error")); }
@Test public void normal() { Mono.just(1) .handle((v, s) -> s.next(v * 2)) .subscribeWith(AssertSubscriber.create()) .assertContainValues(singleton(2)) .assertNoError() .assertComplete(); } @Test
@Test public void normal() { Set<Integer> expectedValues = new HashSet<>(Arrays.asList(2, 4, 6, 8, 10)); Flux.range(1, 5) .handle((v, s) -> s.next(v * 2)) .subscribeWith(AssertSubscriber.create()) .assertContainValues(expectedValues) .assertNoError() .assertComplete(); }
@Test public void contextTest() { StepVerifier.create(Flux.generate(s -> s.next(s.currentContext() .get(AtomicInteger.class) .incrementAndGet())) .take(10) .subscriberContext(ctx -> ctx.put(AtomicInteger.class, new AtomicInteger()))) .expectNext(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) .verifyComplete(); }
@Test public void normalSyncFusion() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Set<Integer> expectedValues = new HashSet<>(Arrays.asList(2, 4, 6, 8, 10)); ts.requestedFusionMode(SYNC); Flux.range(1, 5).<Integer>handle((v, s) -> s.next(v * 2)).subscribe(ts); ts.assertContainValues(expectedValues) .assertNoError() .assertComplete() .assertFuseableSource() .assertFusionMode(SYNC); }
@Test public void contextGetMono() throws InterruptedException { StepVerifier.create(Mono.just(1) .log() .handle((d, c) -> c.next(c.currentContext().get("test") + "" + d)) .handle((d, c) -> c.next(c.currentContext().get("test2") + "" + d)) .subscriberContext(ctx -> ctx.put("test2", "bar")) .subscriberContext(ctx -> ctx.put("test", "foo")) .log()) .expectNext("barfoo1") .verifyComplete(); }
@Test public void producingHandle() { Flux<String> alphabet = Flux.just(-1, 30, 13, 9, 20) .handle((i, sink) -> { String letter = alphabet(i); // <1> if (letter != null) // <2> sink.next(letter); // <3> }); alphabet.subscribe(System.out::println); StepVerifier.create(alphabet) .expectNext("M", "I", "T") .verifyComplete(); }
@Test public void generateJust() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Flux.<Integer>generate(o -> { o.next(1); o.complete(); }).subscribe(ts); ts.assertValues(1) .assertNoError() .assertComplete(); }