@Override protected void subscribeActual(SingleObserver<? super Notification<T>> observer) { source.subscribe(new MaterializeSingleObserver<T>(observer)); } }
@Test(expected = NullPointerException.class) public void subscribeOnSuccessNull() { just1.subscribe(null, new Consumer<Throwable>() { @Override public void accept(Throwable e) { } }); }
@Test(expected = NullPointerException.class) public void subscribeOnErrorNull() { just1.subscribe(new Consumer<Integer>() { @Override public void accept(Integer v) { } }, null); }
@Override public void run() { error.completable.toSingleDefault(0).subscribe(); } });
@Test public void testToMultimap() { Observable<String> source = Observable.just("a", "b", "cc", "dd"); Single<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc); Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>(); expected.put(1, Arrays.asList("a", "b")); expected.put(2, Arrays.asList("cc", "dd")); mapped.subscribe(singleObserver); verify(singleObserver, never()).onError(any(Throwable.class)); verify(singleObserver, times(1)).onSuccess(expected); }
@Test public void testToMultimapWithValueSelector() { Flowable<String> source = Flowable.just("a", "b", "cc", "dd"); Single<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc, duplicate); Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>(); expected.put(1, Arrays.asList("aa", "bb")); expected.put(2, Arrays.asList("cccc", "dddd")); mapped.subscribe(singleObserver); verify(singleObserver, never()).onError(any(Throwable.class)); verify(singleObserver, times(1)).onSuccess(expected); }
@Test public void testFirstOrDefault() { Single<Integer> o = Observable.just(1, 2, 3) .first(4); o.subscribe(wo); InOrder inOrder = inOrder(wo); inOrder.verify(wo, times(1)).onSuccess(1); inOrder.verifyNoMoreInteractions(); }
@Test public void testContains() { Single<Boolean> o = Observable.just("a", "b", "c").contains("b"); // FIXME nulls not allowed, changed to "c" SingleObserver<Boolean> observer = TestHelper.mockSingleObserver(); o.subscribe(observer); verify(observer, times(1)).onSuccess(true); verify(observer, never()).onSuccess(false); verify(observer, never()).onError( any(Throwable.class)); }
private void verifyError(Single<Boolean> single) { SingleObserver<Boolean> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError(isA(TestException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefault() { Single<Integer> o = Observable.just(1).single(2); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(1); inOrder.verifyNoMoreInteractions(); }
@Test public void testCountZeroItems() { Flowable<String> flowable = Flowable.empty(); flowable.count().subscribe(wo); // we should be called only once verify(wo).onSuccess(0L); verify(wo, never()).onError(any(Throwable.class)); }
@Test @Ignore("Null values are not allowed") public void testListWithNullValue() { Flowable<String> w = Flowable.fromIterable(Arrays.asList("one", null, "three")); Single<List<String>> single = w.toList(); SingleObserver<List<String>> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); verify(observer, times(1)).onSuccess(Arrays.asList("one", null, "three")); verify(observer, Mockito.never()).onError(any(Throwable.class)); }
@Test public void testIsEmptyWithTwoItems() { Flowable<Integer> w = Flowable.just(1, 2); Single<Boolean> single = w.isEmpty(); SingleObserver<Boolean> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); verify(observer, never()).onSuccess(true); verify(observer, times(1)).onSuccess(false); verify(observer, never()).onError(any(Throwable.class)); }
@Test public void testIsEmptyWithOneItemFlowable() { Flowable<Integer> w = Flowable.just(1); Single<Boolean> single = w.isEmpty(); SingleObserver<Boolean> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); verify(observer, never()).onSuccess(true); verify(observer, times(1)).onSuccess(false); verify(observer, never()).onError(any(Throwable.class)); }
@Test public void testLastOrDefault() { Single<Integer> single = Flowable.just(1, 2, 3) .last(4); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(3); // inOrder.verify(observer, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void testLastOrDefaultWithEmpty() { Single<Integer> single = Flowable.<Integer> empty() .last(1); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(1); // inOrder.verify(observer, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void singleSubscribe0() { Single.error(new TestException()) .subscribe(); }
@Test public void testLastOrDefaultWithEmpty() { Single<Integer> o = Observable.<Integer> empty() .last(1); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(1); // inOrder.verify(observer, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithTooManyElements() { Single<Integer> single = Flowable.just(1, 2).single(3); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void singleSubscribe1() { Single.error(new TestException()) .subscribe(Functions.emptyConsumer()); }