@Test public void testMergeALotOfSourcesOneByOneSynchronouslyTakeHalf() { int n = 10000; List<Observable<Integer>> sourceList = new ArrayList<Observable<Integer>>(n); for (int i = 0; i < n; i++) { sourceList.add(Observable.just(i)); } Iterator<Integer> it = Observable.merge(Observable.fromIterable(sourceList), 1).take(n / 2).blockingIterable().iterator(); int j = 0; while (it.hasNext()) { assertEquals((Integer)j, it.next()); j++; } assertEquals(j, n / 2); }
@Test public void testErrorThrownIssue1685() { Subject<Object> subject = ReplaySubject.create(); Observable.error(new RuntimeException("oops")) .materialize() .delay(1, TimeUnit.SECONDS) .dematerialize() .subscribe(subject); subject.subscribe(); subject.materialize().blockingFirst(); System.out.println("Done"); }
@Test public void emptyConditional() { Observable.<Integer>empty() .doAfterNext(afterNext) .filter(Functions.alwaysTrue()) .subscribeWith(ts) .assertResult(); assertTrue(values.isEmpty()); }
@Override public Integer apply(Integer v) throws Exception { Observable.just(1).delay(10, TimeUnit.SECONDS).blockingFirst(); return v; } })
public void groupByKeyNull() { just1.groupBy(new Function<Integer, Object>() { @Override public Object apply(Integer v) { return null; } }).blockingSubscribe(); }
/** * Converts this {@code Observable} into an {@link Iterable}. * <p> * <img width="640" height="315" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/B.toIterable.png" alt=""> * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code blockingIterable} does not operate by default on a particular {@link Scheduler}.</dd> * </dl> * * @return an {@link Iterable} version of this {@code Observable} * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX documentation: To</a> */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Iterable<T> blockingIterable() { return blockingIterable(bufferSize()); }
@Test public void testError2() { Observable<Integer> source = Observable.concat(Observable.just(0), Observable.<Integer> error(new TestException("Forced failure"))); Observable<Integer> m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); TestObserver<Object> ts = new TestObserver<Object>(); m.subscribe(ts); ts.awaitTerminalEvent(); assertEquals(1, ts.errorCount()); ts.assertValueCount(1); }
@Test public void innerEscapeCompleted() { Observable<Integer> source = Observable.just(0); Observable<Integer> m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); TestObserver<Object> ts = new TestObserver<Object>(); m.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); System.out.println(ts.values()); }
@Test public void normalNonDelayErrorOuterObservable() { Observable.range(1, 10).concatWith(Observable.<Integer>error(new TestException())) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }, false).toObservable() .test() .assertFailure(TestException.class); }
@Test public void delayWithTimeDelayError() throws Exception { Observable.just(1).concatWith(Observable.<Integer>error(new TestException())) .delay(100, TimeUnit.MILLISECONDS, true) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(TestException.class, 1); }
@Test public void forEachWileWithError() { final List<Object> list = new ArrayList<Object>(); Observable.range(1, 5).concatWith(Observable.<Integer>error(new TestException())) .doOnNext(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { list.add(v); } }) .forEachWhile(new Predicate<Integer>() { @Override public boolean test(Integer v) throws Exception { return true; } }, new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { list.add(100); } }); assertEquals(Arrays.asList(1, 2, 3, 4, 5, 100), list); }
@Test public void testWhenMaxConcurrentIsOne() { for (int i = 0; i < 100; i++) { List<Observable<String>> os = new ArrayList<Observable<String>>(); os.add(Observable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); os.add(Observable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); os.add(Observable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); List<String> expected = Arrays.asList("one", "two", "three", "four", "five", "one", "two", "three", "four", "five", "one", "two", "three", "four", "five"); Iterator<String> iter = Observable.merge(os, 1).blockingIterable().iterator(); List<String> actual = new ArrayList<String>(); while (iter.hasNext()) { actual.add(iter.next()); } assertEquals(expected, actual); } }
@Test public void testFlatMapTransformsMergeException() { Observable<Integer> onNext = Observable.error(new TestException()); Observable<Integer> onComplete = Observable.fromIterable(Arrays.asList(4)); Observable<Integer> onError = Observable.fromIterable(Arrays.asList(5)); Observable<Integer> source = Observable.fromIterable(Arrays.asList(10, 20, 30)); Observer<Object> o = TestHelper.mockObserver(); source.flatMap(just(onNext), just(onError), funcThrow0(onComplete)).subscribe(o); verify(o).onError(any(TestException.class)); verify(o, never()).onNext(any()); verify(o, never()).onComplete(); }
@Test public void normalDelayErrorAll() { TestObserver<Integer> to = Observable.range(1, 10).concatWith(Observable.<Integer>error(new TestException())) .flatMapMaybe(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { return Maybe.error(new TestException()); } }, true) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); for (int i = 0; i < 11; i++) { TestCommonHelper.assertError(errors, i, TestException.class); } }
@Test public void normalDelayErrorAll() { TestObserver<Integer> to = Observable.range(1, 10).concatWith(Observable.<Integer>error(new TestException())) .flatMapSingle(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.error(new TestException()); } }, true) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); for (int i = 0; i < 11; i++) { TestCommonHelper.assertError(errors, i, TestException.class); } }
@Test public void boundaryOnError() { TestObserver<Object> to = Observable.error(new TestException()) .window(Observable.never()) .flatMap(Functions.<Observable<Object>>identity(), true) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(errors, 0, TestException.class); }
@Override public Integer apply(Integer v) throws Exception { Observable.just(1).delay(10, TimeUnit.SECONDS).blockingIterable().iterator().next(); return v; } })
@Test public void normalDelayError() { Observable.range(1, 10) .flatMapMaybe(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { return Maybe.just(v); } }, true) .test() .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); }