@Test public void connectImmediately() { EmitterProcessor<Integer> e = EmitterProcessor.create(); AtomicReference<Disposable> cancel = new AtomicReference<>(); e.publish().autoConnect(0, cancel::set); Assert.assertNotNull(cancel.get()); Assert.assertTrue("sp has no subscribers?", e.downstreamCount() != 0); cancel.get().dispose(); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); }
@Test public void connectAfterMany() { EmitterProcessor<Integer> e = EmitterProcessor.create(); AtomicReference<Disposable> cancel = new AtomicReference<>(); Flux<Integer> p = e.publish().autoConnect(2, cancel::set); Assert.assertNull(cancel.get()); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); p.subscribe(AssertSubscriber.create()); Assert.assertNull(cancel.get()); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); p.subscribe(AssertSubscriber.create()); Assert.assertNotNull(cancel.get()); Assert.assertTrue("sp has no subscribers?", e.downstreamCount() != 0); cancel.get().dispose(); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); }
@Test public void cancelComposes() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); EmitterProcessor<Integer> sp = EmitterProcessor.create(); sp.publish(o -> Flux.<Integer>never()) .subscribe(ts); Assert.assertTrue("Not subscribed?", sp.downstreamCount() != 0); ts.cancel(); Assert.assertTrue("Still subscribed?", sp.downstreamCount() == 0); }
@Test public void cancelComposes2() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); EmitterProcessor<Integer> sp = EmitterProcessor.create(); sp.publish(o -> Flux.<Integer>empty()) .subscribe(ts); Assert.assertFalse("Still subscribed?", sp.downstreamCount() == 1); }
@Test public void normalTwoSubscribers() { EmitterProcessor<Integer> e = EmitterProcessor.create(); Flux<Integer> p = e.publish().refCount(2); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); AssertSubscriber<Integer> ts1 = AssertSubscriber.create(); p.subscribe(ts1); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); AssertSubscriber<Integer> ts2 = AssertSubscriber.create(); p.subscribe(ts2); Assert.assertTrue("sp has no subscribers?", e.downstreamCount() != 0); e.onNext(1); e.onNext(2); ts1.cancel(); Assert.assertTrue("sp has no subscribers?", e.downstreamCount() != 0); e.onNext(3); ts2.cancel(); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); ts1.assertValues(1, 2) .assertNoError() .assertNotComplete(); ts2.assertValues(1, 2, 3) .assertNoError() .assertNotComplete(); }
@Test public void normal() { EmitterProcessor<Integer> e = EmitterProcessor.create(); Flux<Integer> p = e.publish().refCount(); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); AssertSubscriber<Integer> ts1 = AssertSubscriber.create(); p.subscribe(ts1); Assert.assertTrue("sp has no subscribers?", e.downstreamCount() != 0); AssertSubscriber<Integer> ts2 = AssertSubscriber.create(); p.subscribe(ts2); Assert.assertTrue("sp has no subscribers?", e.downstreamCount() != 0); e.onNext(1); e.onNext(2); ts1.cancel(); Assert.assertTrue("sp has no subscribers?", e.downstreamCount() != 0); e.onNext(3); ts2.cancel(); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); ts1.assertValues(1, 2) .assertNoError() .assertNotComplete(); ts2.assertValues(1, 2, 3) .assertNoError() .assertNotComplete(); }
@Test public void flatMapUnbounded() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); AtomicInteger emission = new AtomicInteger(); Flux<Integer> source = Flux.range(1, 1000).doOnNext(v -> emission.getAndIncrement()); EmitterProcessor<Integer> source1 = EmitterProcessor.create(); EmitterProcessor<Integer> source2 = EmitterProcessor.create(); source.flatMap(v -> v == 1 ? source1 : source2, Integer.MAX_VALUE, 32).subscribe(ts); Assert.assertEquals(1000, emission.get()); ts.assertNoValues() .assertNoError() .assertNotComplete(); Assert.assertTrue("source1 no subscribers?", source1.downstreamCount() != 0); Assert.assertTrue("source2 no subscribers?", source2.downstreamCount() != 0); source1.onNext(1); source1.onComplete(); source2.onNext(2); source2.onComplete(); ts.assertValueCount(1000) .assertNoError() .assertComplete(); }
@Test public void singleSubscriberOnly() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); AtomicInteger emission = new AtomicInteger(); Flux<Integer> source = Flux.range(1, 2).doOnNext(v -> emission.getAndIncrement()); EmitterProcessor<Integer> source1 = EmitterProcessor.create(); EmitterProcessor<Integer> source2 = EmitterProcessor.create(); source.flatMap(v -> v == 1 ? source1 : source2, 1, 32).subscribe(ts); Assert.assertEquals(1, emission.get()); ts.assertNoValues() .assertNoError() .assertNotComplete(); Assert.assertTrue("source1 no subscribers?", source1.downstreamCount() != 0); Assert.assertFalse("source2 has subscribers?", source2.downstreamCount() != 0); source1.onNext(1); source2.onNext(10); source1.onComplete(); source2.onNext(2); source2.onComplete(); ts.assertValues(1, 10, 2) .assertNoError() .assertComplete(); }
@Test public void disconnectBackpressured() { AssertSubscriber<Integer> ts = AssertSubscriber.create(0); EmitterProcessor<Integer> e = EmitterProcessor.create(); ConnectableFlux<Integer> p = e.publish(); p.subscribe(ts); Disposable r = p.connect(); r.dispose(); ts.assertNoValues() .assertError(CancellationException.class) .assertNotComplete(); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); }
@Test public void disconnect() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); EmitterProcessor<Integer> e = EmitterProcessor.create(); ConnectableFlux<Integer> p = e.publish(); p.subscribe(ts); Disposable r = p.connect(); e.onNext(1); e.onNext(2); r.dispose(); ts.assertValues(1, 2) .assertError(CancellationException.class) .assertNotComplete(); Assert.assertFalse("sp has subscribers?", e.downstreamCount() != 0); }