@Test(expected = NullPointerException.class) public void subscribeOnNull() { just1.subscribeOn(null); }
@Override public Observable<Integer> apply(Integer t) { return Observable.just(1).subscribeOn(Schedulers.computation()); } }).subscribe(ts);
@Override public Observable<Integer> apply(Integer t1) { return composer(Observable.range(t1 * 10, 2), subscriptionCount, m) .subscribeOn(Schedulers.computation()); } }, new BiFunction<Integer, Integer, Integer>() {
@Override public Observable<Integer> apply(Integer t) { return Observable.range(1, 1000).subscribeOn(Schedulers.computation()); } }).observeOn(Schedulers.newThread()).subscribe(ts);
@Override public Observable<Integer> apply(Integer t1) { return composer(Observable.range(t1 * 10, 2), subscriptionCount, m) .subscribeOn(Schedulers.computation()); } }, m);
@Override public Observable<String> apply(Throwable t1) { return Observable.just("twoResume", "threeResume").subscribeOn(Schedulers.computation()); }
@Test(/* timeout = 1000, */expected = RuntimeException.class) public void testHasNextThrows() { TestScheduler scheduler = new TestScheduler(); Observable<Long> source = Observable.<Long> error(new RuntimeException("Forced failure!")).subscribeOn(scheduler); Iterable<Long> iter = source.blockingLatest(); Iterator<Long> it = iter.iterator(); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); it.hasNext(); }
@Test(timeout = 1000, expected = RuntimeException.class) public void testNextThrows() { TestScheduler scheduler = new TestScheduler(); Observable<Long> source = Observable.<Long> error(new RuntimeException("Forced failure!")).subscribeOn(scheduler); Iterable<Long> iter = source.blockingLatest(); Iterator<Long> it = iter.iterator(); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); it.next(); }
@Override public CompletableSource apply(Integer v) throws Exception { return Observable.range(1, 100).subscribeOn(Schedulers.computation()).ignoreElements(); } })
@Override public CompletableSource apply(Integer v) throws Exception { return Observable.range(1, 100).subscribeOn(Schedulers.computation()).ignoreElements(); } }).toObservable()
@Override public Observable<Integer> apply(Integer t) { Observable<Integer> o = Observable.just(t) .subscribeOn(sch) ; Subject<Integer> subject = UnicastSubject.create(); o.subscribe(subject); return subject; } };
@Test public void testJustWithScheduler() { TestScheduler scheduler = new TestScheduler(); Observable<Integer> o = Observable.fromArray(1, 2).subscribeOn(scheduler); Observer<Integer> observer = TestHelper.mockObserver(); o.subscribe(observer); scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onNext(1); inOrder.verify(observer, times(1)).onNext(2); inOrder.verify(observer, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test(timeout = 5000) public void testTake() throws Exception { List<Observable<Integer>> sourceList = new ArrayList<Observable<Integer>>(3); sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io())); sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io())); sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io())); TestObserver<Integer> ts = new TestObserver<Integer>(); Observable.merge(sourceList, 2).take(5).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); ts.assertValueCount(5); } }
@Test public void blockingFirstDefault() { assertEquals(1, Observable.<Integer>empty() .subscribeOn(Schedulers.computation()).blockingFirst(1).intValue()); }
@Test public void blockingFirst() { assertEquals(1, Observable.range(1, 10) .subscribeOn(Schedulers.computation()).blockingFirst().intValue()); }
@Test public void blockingSubscribeConsumerConsumer() { final List<Object> list = new ArrayList<Object>(); Observable.range(1, 5) .subscribeOn(Schedulers.computation()) .blockingSubscribe(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { list.add(v); } }, Functions.emptyConsumer()); assertEquals(Arrays.asList(1, 2, 3, 4, 5), list); }
@Test public void dispose() { TestHelper.checkDisposed(Observable.just(1).subscribeOn(Schedulers.single())); } }
@Test(timeout = 2000) public void testRepeatTake() { Observable<Integer> xs = Observable.just(1, 2); Object[] ys = xs.repeat().subscribeOn(Schedulers.newThread()).take(4).toList().blockingGet().toArray(); assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys); }
@Test public void testOnError() { TestObserver<String> ts = new TestObserver<String>(); Observable.unsafeCreate(new ObservableSource<String>() { @Override public void subscribe(Observer<? super String> s) { s.onSubscribe(Disposables.empty()); s.onError(new RuntimeException("fail")); } }).subscribeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(1000, TimeUnit.MILLISECONDS); ts.assertTerminated(); }
@Test public void cancelBeforeActualSubscribe() { TestScheduler test = new TestScheduler(); TestObserver<Integer> to = new TestObserver<Integer>(); Observable.just(1).hide() .subscribeOn(test).subscribe(to); to.dispose(); test.advanceTimeBy(1, TimeUnit.SECONDS); to .assertSubscribed() .assertNoValues() .assertNotTerminated(); }