@Test(expected = NullPointerException.class) public void mergeIterableNull() { Observable.merge((Iterable<Observable<Object>>)null, 128, 128); }
@SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void mergeIterableOneIsNull() { Observable.merge(Arrays.asList(just1, null), 128, 128).blockingLast(); }
private Observable<Integer> mergeNSyncStreamsOfN(final int outerSize, final int innerSize) { Observable<Observable<Integer>> os = Observable.range(1, outerSize) .map(new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer i) { return Observable.range(1, innerSize); } }); return Observable.merge(os); }
@Test(expected = NullPointerException.class) public void mergeIterableIteratorNull() { Observable.merge(new Iterable<Observable<Object>>() { @Override public Iterator<Observable<Object>> iterator() { return null; } }, 128, 128).blockingLast(); }
private Observable<Integer> mergeNAsyncStreamsOfN(final int outerSize, final int innerSize) { Observable<Observable<Integer>> os = Observable.range(1, outerSize) .map(new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer i) { return Observable.range(1, innerSize).subscribeOn(Schedulers.computation()); } }); return Observable.merge(os); }
@Test public void testMergeList() { final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable()); final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable()); List<Observable<String>> listOfObservables = new ArrayList<Observable<String>>(); listOfObservables.add(o1); listOfObservables.add(o2); Observable<String> m = Observable.merge(listOfObservables); m.subscribe(stringObserver); verify(stringObserver, never()).onError(any(Throwable.class)); verify(stringObserver, times(1)).onComplete(); verify(stringObserver, times(2)).onNext("hello"); }
@Test public void testMergeArray() { final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable()); final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable()); Observable<String> m = Observable.merge(o1, o2); m.subscribe(stringObserver); verify(stringObserver, never()).onError(any(Throwable.class)); verify(stringObserver, times(2)).onNext("hello"); verify(stringObserver, times(1)).onComplete(); }
@Test public void testMergeArrayWithThreading() { final TestASynchronousObservable o1 = new TestASynchronousObservable(); final TestASynchronousObservable o2 = new TestASynchronousObservable(); Observable<String> m = Observable.merge(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2)); TestObserver<String> ts = new TestObserver<String>(stringObserver); m.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); verify(stringObserver, never()).onError(any(Throwable.class)); verify(stringObserver, times(2)).onNext("hello"); verify(stringObserver, times(1)).onComplete(); }
/** * This won't compile if super/extends isn't done correctly on generics. */ @Test public void testCovarianceOfMerge() { Observable<HorrorMovie> horrors = Observable.just(new HorrorMovie()); Observable<Observable<HorrorMovie>> metaHorrors = Observable.just(horrors); Observable.<Media> merge(metaHorrors); }
@Test public void testMergeCovariance3() { Observable<Movie> o1 = Observable.just(new HorrorMovie(), new Movie()); Observable<Media> o2 = Observable.just(new Media(), new HorrorMovie()); List<Media> values = Observable.merge(o1, o2).toList().blockingGet(); assertTrue(values.get(0) instanceof HorrorMovie); assertTrue(values.get(1) instanceof Movie); assertTrue(values.get(2) != null); assertTrue(values.get(3) instanceof HorrorMovie); }
@Test public void mergeScalar() { Observable.merge(Observable.just(Observable.just(1))) .test() .assertResult(1); }
@Test public void mergeScalarEmpty() { Observable.merge(Observable.just(Observable.empty()).hide()) .test() .assertResult(); }
@Test public void mergeScalarError() { Observable.merge(Observable.just(Observable.fromCallable(new Callable<Object>() { @Override public Object call() throws Exception { throw new TestException(); } })).hide()) .test() .assertFailure(TestException.class); }
@Test public void mergeScalar2() { Observable.merge(Observable.just(Observable.just(1)).hide()) .test() .assertResult(1); }
@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 @Ignore("Null values not permitted") public void mergeWithNullValues() { System.out.println("mergeWithNullValues"); TestObserver<String> ts = new TestObserver<String>(); Observable.merge(Observable.just(null, "one"), Observable.just("two", null)).subscribe(ts); ts.assertTerminated(); ts.assertNoErrors(); ts.assertValues(null, "one", "two", null); }
@Test @Ignore("Null values are not permitted") public void mergingNullObservable() { TestObserver<String> ts = new TestObserver<String>(); Observable.merge(Observable.just("one"), null).subscribe(ts); ts.assertNoErrors(); ts.assertValue("one"); }
@Test public void testMergeCovariance() { Observable<Media> o1 = Observable.<Media> just(new HorrorMovie(), new Movie()); Observable<Media> o2 = Observable.just(new Media(), new HorrorMovie()); Observable<Observable<Media>> os = Observable.just(o1, o2); List<Media> values = Observable.merge(os).toList().blockingGet(); assertEquals(4, values.size()); }
@Test public void testMergeCovariance2() { Observable<Media> o1 = Observable.just(new HorrorMovie(), new Movie(), new Media()); Observable<Media> o2 = Observable.just(new Media(), new HorrorMovie()); Observable<Observable<Media>> os = Observable.just(o1, o2); List<Media> values = Observable.merge(os).toList().blockingGet(); assertEquals(5, values.size()); }
@Test public void debounceWithTimeBackpressure() throws InterruptedException { TestScheduler scheduler = new TestScheduler(); TestObserver<Integer> observer = new TestObserver<Integer>(); Observable.merge( Observable.just(1), Observable.just(2).delay(10, TimeUnit.MILLISECONDS, scheduler) ).debounce(20, TimeUnit.MILLISECONDS, scheduler).take(1).subscribe(observer); scheduler.advanceTimeBy(30, TimeUnit.MILLISECONDS); observer.assertValue(2); observer.assertTerminated(); observer.assertNoErrors(); }