@Override public Object apply(Flowable<Object> f) throws Exception { return f.materialize(); } }, false, null, null, Notification.createOnComplete());
@Override public Flowable<Notification<Object>> apply(Flowable<Object> f) throws Exception { return f.materialize(); } });
@Override public Iterator<T> iterator() { LatestSubscriberIterator<T> lio = new LatestSubscriberIterator<T>(); Flowable.<T>fromPublisher(source).materialize().subscribe(lio); return lio; }
@Test public void testDematerialize2() { Throwable exception = new Throwable("test"); Flowable<Integer> flowable = Flowable.error(exception); Flowable<Integer> dematerialize = flowable.materialize().dematerialize(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); dematerialize.subscribe(subscriber); verify(subscriber, times(1)).onError(exception); verify(subscriber, times(0)).onComplete(); verify(subscriber, times(0)).onNext(any(Integer.class)); }
@Test public void testDematerialize3() { Exception exception = new Exception("test"); Flowable<Integer> flowable = Flowable.error(exception); Flowable<Integer> dematerialize = flowable.materialize().dematerialize(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); dematerialize.subscribe(subscriber); verify(subscriber, times(1)).onError(exception); verify(subscriber, times(0)).onComplete(); verify(subscriber, times(0)).onNext(any(Integer.class)); }
@Test public void testDematerialize1() { Flowable<Notification<Integer>> notifications = Flowable.just(1, 2).materialize(); Flowable<Integer> dematerialize = notifications.dematerialize(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); dematerialize.subscribe(subscriber); verify(subscriber, times(1)).onNext(1); verify(subscriber, times(1)).onNext(2); verify(subscriber, times(1)).onComplete(); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test public void simpleSelector() { Flowable<Notification<Integer>> notifications = Flowable.just(1, 2).materialize(); Flowable<Integer> dematerialize = notifications.dematerialize(Functions.<Notification<Integer>>identity()); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); dematerialize.subscribe(subscriber); verify(subscriber, times(1)).onNext(1); verify(subscriber, times(1)).onNext(2); verify(subscriber, times(1)).onComplete(); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test public void testMaterializeDematerializeChaining() { Flowable<Integer> obs = Flowable.just(1); Flowable<Integer> chained = obs.materialize() .dematerialize(Functions.<Notification<Integer>>identity()); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); chained.subscribe(subscriber); verify(subscriber, times(1)).onNext(1); verify(subscriber, times(1)).onComplete(); verify(subscriber, times(0)).onError(any(Throwable.class)); }
@Test public void testHonorsContractWhenThrows() { Flowable<Integer> source = Flowable.error(new TestException()); Flowable<Integer> result = source.materialize().dematerialize(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); result.subscribe(subscriber); verify(subscriber, never()).onNext(any(Integer.class)); verify(subscriber, never()).onComplete(); verify(subscriber).onError(any(TestException.class)); }
@Test public void testHonorsContractWhenCompleted() { Flowable<Integer> source = Flowable.just(1); Flowable<Integer> result = source.materialize().dematerialize(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); result.subscribe(subscriber); verify(subscriber).onNext(1); verify(subscriber).onComplete(); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test public void badRequest() { TestHelper.assertBadRequestReported(Flowable.just(1).materialize()); } }
@Test public void dispose() { TestHelper.checkDisposed(Flowable.just(1).materialize()); }
@Test public void testMultipleSubscribes() throws InterruptedException, ExecutionException { final TestAsyncErrorObservable o = new TestAsyncErrorObservable("one", "two", null, "three"); Flowable<Notification<String>> m = Flowable.unsafeCreate(o).materialize(); assertEquals(3, m.toList().toFuture().get().size()); assertEquals(3, m.toList().toFuture().get().size()); }
@Test public void selectorNull() { Flowable.just(1, 2) .materialize() .dematerialize(new Function<Notification<Integer>, Notification<Object>>() { @Override public Notification<Object> apply(Notification<Integer> v) throws Exception { return null; } }) .test() .assertFailure(NullPointerException.class); }
@Test public void testBackpressureWithError() { TestSubscriber<Notification<Integer>> ts = new TestSubscriber<Notification<Integer>>(0L); Flowable.<Integer> error(new IllegalArgumentException()).materialize().subscribe(ts); ts.assertNoValues(); ts.request(1); ts.assertValueCount(1); ts.assertComplete(); }
@Test public void selectorCrash() { Flowable.just(1, 2) .materialize() .dematerialize(new Function<Notification<Integer>, Notification<Object>>() { @Override public Notification<Object> apply(Notification<Integer> v) throws Exception { throw new TestException(); } }) .test() .assertFailure(TestException.class); }
@Test public void testBackpressureOnEmptyStream() { TestSubscriber<Notification<Integer>> ts = new TestSubscriber<Notification<Integer>>(0L); Flowable.<Integer> empty().materialize().subscribe(ts); ts.assertNoValues(); ts.request(1); ts.assertValueCount(1); assertTrue(ts.values().get(0).isOnComplete()); ts.assertComplete(); }
@Test public void testUnsubscribeJustBeforeCompletionNotificationShouldPreventThatNotificationArriving() { TestSubscriber<Notification<Integer>> ts = new TestSubscriber<Notification<Integer>>(0L); Flowable.<Integer>empty().materialize() .subscribe(ts); ts.assertNoValues(); ts.dispose(); ts.request(1); ts.assertNoValues(); }
@Test public void testBackpressureNoError() { TestSubscriber<Notification<Integer>> ts = new TestSubscriber<Notification<Integer>>(0L); Flowable.just(1, 2, 3).materialize().subscribe(ts); ts.assertNoValues(); ts.request(1); ts.assertValueCount(1); ts.request(2); ts.assertValueCount(3); ts.request(1); ts.assertValueCount(4); ts.assertComplete(); }
@Test public void backpressure() { TestSubscriber<Notification<Integer>> ts = Flowable.range(1, 5).materialize().test(0); ts.assertEmpty(); ts.request(5); ts.assertValueCount(5) .assertNoErrors() .assertNotComplete(); ts.request(1); ts.assertValueCount(6) .assertNoErrors() .assertComplete(); }