@Test public void testDistinctOfNoneWithKeySelector() { Observable<String> src = Observable.empty(); src.distinct(TO_UPPER_WITH_EXCEPTION).subscribe(w); verify(w, never()).onNext(anyString()); verify(w, never()).onError(any(Throwable.class)); verify(w, times(1)).onComplete(); }
@Test @Ignore("Null values no longer allowed") public void testDistinctUntilChangedOfSourceWithExceptionsFromKeySelector() { Observable<String> src = Observable.just("a", "b", null, "c"); src.distinctUntilChanged(TO_UPPER_WITH_EXCEPTION).subscribe(w); InOrder inOrder = inOrder(w); inOrder.verify(w, times(1)).onNext("a"); inOrder.verify(w, times(1)).onNext("b"); verify(w, times(1)).onError(any(NullPointerException.class)); inOrder.verify(w, never()).onNext(anyString()); inOrder.verify(w, never()).onComplete(); }
@Test public void testTakeFirstWithPredicateOfSome() { Observable<Integer> o = Observable.just(1, 3, 5, 4, 6, 3); o.filter(IS_EVEN).take(1).subscribe(w); verify(w, times(1)).onNext(anyInt()); verify(w).onNext(4); verify(w, times(1)).onComplete(); verify(w, never()).onError(any(Throwable.class)); }
@Test public void testDematerialize2() { Throwable exception = new Throwable("test"); Observable<Integer> o = Observable.error(exception); Observable<Integer> dematerialize = o.materialize().dematerialize(); Observer<Integer> observer = TestHelper.mockObserver(); dematerialize.subscribe(observer); verify(observer, times(1)).onError(exception); verify(observer, times(0)).onComplete(); verify(observer, times(0)).onNext(any(Integer.class)); }
@Test public void testSkipAndCountGaplessBuffers() { Observable<String> source = Observable.just("one", "two", "three", "four", "five"); Observable<List<String>> buffered = source.buffer(3, 3); buffered.subscribe(observer); InOrder inOrder = Mockito.inOrder(observer); inOrder.verify(observer, Mockito.times(1)).onNext(list("one", "two", "three")); inOrder.verify(observer, Mockito.times(1)).onNext(list("four", "five")); inOrder.verify(observer, Mockito.never()).onNext(Mockito.<String>anyList()); inOrder.verify(observer, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(observer, Mockito.times(1)).onComplete(); }
@Test public void testDefaultIfEmptyWithEmpty() { Observable<Integer> source = Observable.empty(); Observable<Integer> observable = source.defaultIfEmpty(10); Observer<Integer> observer = TestHelper.mockObserver(); observable.subscribe(observer); verify(observer).onNext(10); verify(observer).onComplete(); verify(observer, never()).onError(any(Throwable.class)); }
@Test public void observableSubscribe0() { Observable.error(new TestException()) .subscribe(); }
@Test public void testLongTimeAction() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); LongTimeAction action = new LongTimeAction(latch); Observable.just(1).buffer(10, TimeUnit.MILLISECONDS, 10) .subscribe(action); latch.await(); assertFalse(action.fail); }
@Test public void fromFutureReturnsNull() { FutureTask<Object> f = new FutureTask<Object>(Functions.EMPTY_RUNNABLE, null); f.run(); TestObserver<Object> ts = new TestObserver<Object>(); Observable.fromFuture(f).subscribe(ts); ts.assertNoValues(); ts.assertNotComplete(); ts.assertError(NullPointerException.class); }
@Test public void testHelloWorld() { TestObserver<String> ts = new TestObserver<String>(); Single.just("Hello World!").toObservable().subscribe(ts); ts.assertValueSequence(Arrays.asList("Hello World!")); }
@Test public void testAmbWith() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable.just(1).ambWith(Observable.just(2)).subscribe(ts); ts.assertValue(1); } // FIXME Subscribers can't throw
@Test(timeout = 5000) public void subscribeObserverNormal() { TestObserver<Object> ts = new TestObserver<Object>(); normal.completable.toObservable().subscribe(ts); ts.assertComplete(); ts.assertNoValues(); ts.assertNoErrors(); }
@Test public void testSimple2() { Observable.range(1, 100).concatMapEager(toRange).subscribe(ts); ts.assertNoErrors(); ts.assertValueCount(200); ts.assertComplete(); }
@Test public void testMapperThrows() { Observable.just(1).concatMapEager(new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer t) { throw new TestException(); } }).subscribe(ts); ts.assertNoValues(); ts.assertNotComplete(); ts.assertError(TestException.class); }
@Test public void syncFusedConditional() { TestObserver<Integer> ts0 = ObserverFusion.newTest(QueueDisposable.SYNC); Observable.range(1, 5) .doAfterNext(afterNext) .filter(Functions.alwaysTrue()) .subscribe(ts0); ObserverFusion.assertFusion(ts0, QueueDisposable.SYNC) .assertResult(1, 2, 3, 4, 5); assertEquals(Arrays.asList(-1, -2, -3, -4, -5), values); }
@Test public void asyncFusedRejectedConditional() { TestObserver<Integer> ts0 = ObserverFusion.newTest(QueueDisposable.ASYNC); Observable.range(1, 5) .doAfterNext(afterNext) .filter(Functions.alwaysTrue()) .subscribe(ts0); ObserverFusion.assertFusion(ts0, QueueDisposable.NONE) .assertResult(1, 2, 3, 4, 5); assertEquals(Arrays.asList(-1, -2, -3, -4, -5), values); }
@Test public void fusedAsync() { TestObserver<Integer> to = ObserverFusion.newTest(QueueDisposable.ANY); UnicastSubject<Integer> us = UnicastSubject.create(); us .distinct() .subscribe(to); TestHelper.emit(us, 1, 1, 2, 1, 3, 2, 4, 5, 4); ObserverFusion.assertFusion(to, QueueDisposable.ASYNC) .assertResult(1, 2, 3, 4, 5); }
@Test public void andThenNever() { TestObserver<String> ts = new TestObserver<String>(); Completable.never().andThen(Observable.just("foo")).subscribe(ts); ts.assertNoValues(); ts.assertNotTerminated(); }
@SuppressWarnings("unchecked") @Test public void normal() { TestObserver<Integer> ts = ObserverFusion.newTest(QueueDisposable.SYNC); Maybe.mergeArray(Maybe.just(1), Maybe.just(2)) .subscribe(ts); ts .assertOf(ObserverFusion.<Integer>assertFuseable()) .assertOf(ObserverFusion.<Integer>assertFusionMode(QueueDisposable.NONE)) .assertResult(1, 2); }
@Test public void testTake() { TestObserver<Integer> ts = new TestObserver<Integer>(); ObservableCache<Integer> cached = (ObservableCache<Integer>)ObservableCache.from(Observable.range(1, 100)); cached.take(10).subscribe(ts); ts.assertNoErrors(); ts.assertComplete(); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // ts.assertUnsubscribed(); // FIXME no longer valid assertFalse(cached.hasObservers()); }