public CrashDummy assertInnerError(int index, Class<? extends Throwable> clazz) { List<Throwable> cel = TestCommonHelper.compositeList(error); TestCommonHelper.assertError(cel, index, clazz); return this; }
public CrashDummy assertInnerError(int index, Class<? extends Throwable> clazz, String message) { List<Throwable> cel = TestCommonHelper.compositeList(error); TestCommonHelper.assertError(cel, index, clazz, message); return this; }
public CrashDummy assertInnerError(int index, Class<? extends Throwable> clazz, String message) { List<Throwable> cel = TestCommonHelper.compositeList(error); TestCommonHelper.assertError(cel, index, clazz, message); return this; }
/** * Returns an expanded error list of the given test consumer. * @param to the test consumer instance * @return the list */ public static List<Throwable> errorList(TestObserver<?> to) { return TestCommonHelper.compositeList(to.errors().get(0)); }
/** * Returns an expanded error list of the given test consumer. * @param to the test consumer instance * @return the list */ public static List<Throwable> errorList(TestSubscriber<?> to) { return compositeList(to.errors().get(0)); }
public CrashDummy assertInnerError(int index, Class<? extends Throwable> clazz) { List<Throwable> cel = TestCommonHelper.compositeList(error); TestCommonHelper.assertError(cel, index, clazz); return this; }
@Test public void eagerMapperThrowsDisposerThrows() { TestObserver<Integer> ts = Single.using(Functions.justCallable(Disposables.empty()), mapperThrows, disposerThrows) .test() .assertFailure(CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(ts.errors().get(0)); TestCommonHelper.assertError(ce, 0, TestException.class, "Mapper"); TestCommonHelper.assertError(ce, 1, TestException.class, "Disposer"); }
@Test public void onCompleteteNoSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, true, false); SafeObserver<Object> so = cd.toSafe(); so.onComplete(); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class, "onSubscribe()"); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void onNextOnSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onNext(1); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class, "onSubscribe()"); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void onCompleteteNoSubscribeOnErrorCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, true, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onComplete(); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void boundaryOnError() { TestSubscriber<Object> to = Flowable.error(new TestException()) .window(Flowable.never()) .flatMap(Functions.<Flowable<Object>>identity(), true) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(errors, 0, 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); }
@Test public void onErrorCrashes() { TestObserver<Object> to = Single.error(new TestException("Outer")) .doOnError(new Consumer<Throwable>() { @Override public void accept(Throwable v) throws Exception { throw new TestException("Inner"); } }) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(errors, 0, TestException.class, "Outer"); TestCommonHelper.assertError(errors, 1, TestException.class, "Inner"); }
@Test public void errorAcceptThrows() { TestObserver<Void> to = Completable.error(new TestException("Outer")).doOnEvent(new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { throw new TestException("Inner"); } }) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(errors, 0, TestException.class, "Outer"); TestCommonHelper.assertError(errors, 1, TestException.class, "Inner"); }
@Test public void doOnEventThrowsError() { TestObserver<Integer> to = Single.<Integer>error(new TestException("Main")) .doOnEvent(new BiConsumer<Integer, Throwable>() { @Override public void accept(Integer v, Throwable e) throws Exception { throw new TestException("Inner"); } }) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(errors, 0, TestException.class, "Main"); TestCommonHelper.assertError(errors, 1, TestException.class, "Inner"); }
@Test public void predicateThrows() { TestObserver<Object> to = Observable.error(new TestException("Outer")) .retry(new Predicate<Throwable>() { @Override public boolean test(Throwable e) throws Exception { throw new TestException("Inner"); } }) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(errors, 0, TestException.class, "Outer"); TestCommonHelper.assertError(errors, 1, TestException.class, "Inner"); }
@Test public void bipredicateThrows() { TestObserver<Object> to = Observable.error(new TestException("Outer")) .retry(new BiPredicate<Integer, Throwable>() { @Override public boolean test(Integer n, Throwable e) throws Exception { throw new TestException("Inner"); } }) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(errors, 0, TestException.class, "Outer"); TestCommonHelper.assertError(errors, 1, TestException.class, "Inner"); }
@Test public void bipredicateThrows() { TestSubscriber<Object> to = Flowable.error(new TestException("Outer")) .retry(new BiPredicate<Integer, Throwable>() { @Override public boolean test(Integer n, Throwable e) throws Exception { throw new TestException("Inner"); } }) .test() .assertFailure(CompositeException.class); List<Throwable> errors = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(errors, 0, TestException.class, "Outer"); TestCommonHelper.assertError(errors, 1, TestException.class, "Inner"); }
@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 onErrorNull() { TestObserver<Integer> to = Maybe.<Integer>error(new TestException()) .flatMap(Functions.justFunction(Maybe.just(1)), Functions.justFunction((Maybe<Integer>)null), Functions.justCallable(Maybe.just(1))) .test() .assertFailure(CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(to.errors().get(0)); TestCommonHelper.assertError(ce, 0, TestException.class); TestCommonHelper.assertError(ce, 1, NullPointerException.class); }