Java Flowable.error方法代码示例

import io.reactivex.Flowable; //导入方法依赖的package包/类
/**
 * Implements a bidirectional stream -> stream call as {@link Flowable} -> {@link Flowable}, where both the client
 * and the server independently stream to each other.
 */
public static <TRequest, TResponse> Flowable<TResponse> manyToMany(
        Flowable<TRequest> rxRequest,
        Function<StreamObserver<TResponse>, StreamObserver<TRequest>> delegate) {
    try {
        final RxProducerConsumerStreamObserver<TRequest, TResponse> consumerStreamObserver = new RxProducerConsumerStreamObserver<TRequest, TResponse>(rxRequest);
        delegate.apply(new CancellableStreamObserver<TRequest, TResponse>(consumerStreamObserver, new Runnable() {
            @Override
            public void run() {
                consumerStreamObserver.cancel();
            }
        }));
        consumerStreamObserver.rxSubscribe();
        return ((Flowable<TResponse>) consumerStreamObserver.getRxConsumer())
                .lift(new SubscribeOnlyOnceFlowableOperator<TResponse>());
    } catch (Throwable throwable) {
        return Flowable.error(throwable);
    }
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Override
public Flowable<Integer> deleteAll() {
    if(shouldThrowError){
        shouldThrowError = false; // special case because the StoreService needs to call again getAll()
        return Flowable.error(new Exception("deleteAll.error"));
    }

    return getAll(null, null)
            .delay(1, TimeUnit.SECONDS)
            .flatMap(new Function<Optional<List<TestModel>>, Flowable<Integer>>() {
                @Override
                public Flowable<Integer> apply(Optional<List<TestModel>> ts) throws Exception {
                    return Flowable.just(ts.get().size());
                }
            });
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test public void shouldDisableAfter_WithSpecialError() throws Exception {
    Flowable<Integer> broken = Flowable.error(new UnexpectedResponseError("Server down"));

    broken.compose(toogler)
            .subscribe(
                    some -> {},
                    Throwable::printStackTrace,
                    () -> {}
            );

    checkForDisableFirstNotEnableAfter();

}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test public void shouldCoordinateLoading_WithErrorAtFlow() throws Exception {
    Flowable<String> broken = Flowable.error(new RuntimeException("WTF!!"));

    broken.compose(loadingCoordination)
            .subscribe(
                    some -> {},
                    Throwable::printStackTrace,
                    () -> {}
            );

    checkLoadingCoordinated();
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Override
public Flowable<Optional<List<TestModel>>> update(List<TestModel> items) {
    if(shouldThrowError){
        return Flowable.error(new Exception("update.error"));
    }
    return Flowable.just(Optional.wrap(items)).delay(1, TimeUnit.SECONDS);
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Override
public Flowable<Optional<TestModel>> insert(TestModel item) {
    if(shouldThrowError){
        return Flowable.error(new Exception("insertSingle.error"));
    }
    return Flowable.just(Optional.wrap(item)).delay(1, TimeUnit.SECONDS);
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Override
public Flowable<Integer> delete(List<TestModel> items) {
    if(shouldThrowError){
        return Flowable.error(new Exception("delete.error"));
    }
    return Flowable.just(items.size()).delay(1, TimeUnit.SECONDS);
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test public void shouldNotHandle_OtherErrors() {

        NullPointerException npe = new NullPointerException();
        Flowable<String> otherIssue = Flowable.error(npe);

        otherIssue.compose(handler)
                .test()
                .assertError(throwable -> throwable.equals(npe));
    }
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test public void shouldAssignError_WithErrorAtFlow() throws Exception {
    Flowable<String> broken = Flowable.error(new RuntimeException("WTF!!"));

    broken.compose(assignErrorState)
            .subscribe(
                    some -> {},
                    Throwable::printStackTrace,
                    () -> {}
            );

    verify(hide, oneTimeOnly()).run();
    verify(show, oneTimeOnly()).run();
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
private Publisher<T> handleIfRestError(Throwable throwable) {

        if (otherThanNotFound(throwable)) {
            return Flowable.error(new UnexpectedResponseError("Undesired response for this call"));
        }

        if (notFound(throwable)) {
            return Flowable.error(new ContentNotFoundError());
        }

        return Flowable.error(throwable);
    }
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test public void shouldEnableAfter_WhenNoSpecialError() throws Exception {
    Flowable<Integer> broken = Flowable.error(new RuntimeException("WTF!!"));

    broken.compose(toogler)
            .subscribe(
                    some -> {},
                    Throwable::printStackTrace,
                    () -> {}
            );

    checkForDisableFirstEnableAfter();
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
private synchronized Flowable<VectorTileConfig> queryConfigFlowable() {
  final URL url = Resources.getResource("metadata_raw.sql");
  String query;
  try {
    query = Resources.toString(url, Charsets.UTF_8);
  } catch (final IOException ex) {
    return Flowable.error(ex);
  }
  return dataSource.select(query)
      .get(rs -> new VectorTileConfig(rs.getInt("min_zoom"), rs.getInt("max_zoom"),
          rs.getInt("max_zoom_minx"), rs.getInt("max_zoom_miny"), rs.getInt("max_zoom_maxx"),
          rs.getInt("max_zoom_maxy")));
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test public void shouldNotAssignEmpty_WithNotTargetError() throws Exception {
    Flowable<Integer> broken = Flowable.error(new RuntimeException("WTF!!"));

    broken.compose(assignEmptyness)
            .subscribe(
                    some -> {},
                    Throwable::printStackTrace,
                    () -> {}
            );

    verify(hideEmtpyState, oneTimeOnly()).run();
    verify(showEmtpyState, never()).run();
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Override
public Flowable<T> apply(Throwable throwable) throws Exception {
    return Flowable.error(handleException() == null ? ExceptionEngine.handleException(throwable) : handleException());
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test public void shouldHandle_NoInternetAvailable() {
    Flowable<?> noInternet = Flowable.error(new UnknownHostException("No Internet"));
    noInternet.compose(handler)
            .test()
            .assertError(NetworkingError.class);
}