@Test public void testFirstOrElseOfNoneObservable() { Observable<String> src = Observable.empty(); src.first("default").toObservable().subscribe(w); verify(w, times(1)).onNext(anyString()); verify(w, times(1)).onNext("default"); verify(w, never()).onError(any(Throwable.class)); verify(w, times(1)).onComplete(); }
@Test public void testFirstOrElseWithPredicateOfSomeObservable() { Observable<String> src = Observable.just("a", "b", "c", "d", "e", "f"); src.filter(IS_D).first("default").toObservable().subscribe(w); verify(w, times(1)).onNext(anyString()); verify(w, times(1)).onNext("d"); verify(w, never()).onError(any(Throwable.class)); verify(w, times(1)).onComplete(); }
@Test @Ignore("Null values are not allowed") public void testListWithNullValueObservable() { Observable<String> w = Observable.fromIterable(Arrays.asList("one", null, "three")); Observable<List<String>> observable = w.toList().toObservable(); Observer<List<String>> observer = TestHelper.mockObserver(); observable.subscribe(observer); verify(observer, times(1)).onNext(Arrays.asList("one", null, "three")); verify(observer, Mockito.never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testCountAFewItemsObservable() { Observable<String> o = Observable.just("a", "b", "c", "d"); o.count().toObservable().subscribe(w); // we should be called only once verify(w, times(1)).onNext(anyLong()); verify(w).onNext(4L); verify(w, never()).onError(any(Throwable.class)); verify(w, times(1)).onComplete(); }
@Test public void testFirstOrDefaultObservable() { Observable<Integer> o = Observable.just(1, 2, 3) .first(4).toObservable(); Observer<Integer> observer = TestHelper.mockObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onNext(1); inOrder.verify(observer, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void testListWithBlockingFirstObservable() { Observable<String> o = Observable.fromIterable(Arrays.asList("one", "two", "three")); List<String> actual = o.toList().toObservable().blockingFirst(); Assert.assertEquals(Arrays.asList("one", "two", "three"), actual); }
@Test public void testHelloWorld() { TestObserver<String> ts = new TestObserver<String>(); Single.just("Hello World!").toObservable().subscribe(ts); ts.assertValueSequence(Arrays.asList("Hello World!")); }
@SuppressWarnings("unchecked") @Test public void capacityHintObservable() { Observable.range(1, 10) .toList(4) .toObservable() .test() .assertResult(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); }
@Test public void testWithFollowingFirstObservable() { Observable<Integer> o = Observable.fromArray(1, 3, 5, 6); Observable<Boolean> anyEven = o.any(new Predicate<Integer>() { @Override public boolean test(Integer i) { return i % 2 == 0; } }).toObservable(); assertTrue(anyEven.blockingFirst()); } @Test(timeout = 5000)
@Test public void test1Observable() { Observable<Boolean> o = Observable.sequenceEqual( Observable.just("one", "two", "three"), Observable.just("one", "two", "three")).toObservable(); verifyResult(o, true); }
@Test public void testWithEmpty2Observable() { Observable<Boolean> o = Observable.sequenceEqual( Observable.just("one", "two", "three"), Observable.<String> empty()).toObservable(); verifyResult(o, false); }
@Test public void testWithEmpty3Observable() { Observable<Boolean> o = Observable.sequenceEqual( Observable.<String> empty(), Observable.<String> empty()).toObservable(); verifyResult(o, true); }
@Test public void testWithEqualityErrorObservable() { Observable<Boolean> o = Observable.sequenceEqual( Observable.just("one"), Observable.just("one"), new BiPredicate<String, String>() { @Override public boolean test(String t1, String t2) { throw new TestException(); } }).toObservable(); verifyError(o); }
@Test public void firstOrErrorErrorObservable() { Observable.error(new RuntimeException("error")) .firstOrError() .toObservable() .test() .assertNoValues() .assertErrorMessage("error") .assertError(RuntimeException.class); } }
@SuppressWarnings("unchecked") @Test public void error() { Observable.error(new TestException()) .toList() .toObservable() .test() .assertFailure(TestException.class); }
@Test public void prefetchObservable() { Observable.sequenceEqual(Observable.range(1, 20), Observable.range(1, 20), 2) .toObservable() .test() .assertResult(true); }
@Test public void firstOrErrorNoElementObservable() { Observable.empty() .firstOrError() .toObservable() .test() .assertNoValues() .assertError(NoSuchElementException.class); }
@Test public void firstOrErrorMultipleElementsObservable() { Observable.just(1, 2, 3) .firstOrError() .toObservable() .test() .assertNoErrors() .assertValue(1); }
@Test public void testCollectorFailureDoesNotResultInErrorAndCompletedEmissionsObservable() { final RuntimeException e = new RuntimeException(); Burst.item(1).create() // .collect(callableListCreator(), biConsumerThrows(e)) // .toObservable() .test() // .assertError(e) // .assertNotComplete(); }
@Test public void dispose() { TestHelper.checkDisposed(Observable.just(1).toList().toObservable()); TestHelper.checkDisposed(Observable.just(1).toList()); }