@Override public SingleSource<Object> apply(Single<Object> s) throws Exception { return s.onErrorResumeNext(Single.just(1)); } });
@Test(expected = NullPointerException.class) public void onErrorResumeNextFunctionNull() { error.onErrorResumeNext((Function<Throwable, Single<Integer>>)null); }
@Test(expected = NullPointerException.class) public void onErrorResumeNextSingleNull() { error.onErrorResumeNext((Single<Integer>)null); }
@Test public void testOnErrorCalledOnScheduler() throws Exception { final CountDownLatch latch = new CountDownLatch(1); final AtomicReference<Thread> thread = new AtomicReference<Thread>(); Single.<String>error(new Exception()) .delay(0, TimeUnit.MILLISECONDS, Schedulers.newThread()) .doOnError(new Consumer<Throwable>() { @Override public void accept(Throwable throwable) throws Exception { thread.set(Thread.currentThread()); latch.countDown(); } }) .onErrorResumeNext(Single.just("")) .subscribe(); latch.await(); assertNotEquals(Thread.currentThread(), thread.get()); }
public final Single<T> onErrorResumeNext(final Single<? extends T> resumeSingleInCaseOfError) { ObjectHelper.requireNonNull(resumeSingleInCaseOfError, "resumeSingleInCaseOfError is null"); return onErrorResumeNext(Functions.justFunction(resumeSingleInCaseOfError));
@Test public void onErrorResumeNextFunctionReturnsNull() { try { error.onErrorResumeNext(new Function<Throwable, Single<Integer>>() { @Override public Single<Integer> apply(Throwable e) { return null; } }).blockingGet(); } catch (CompositeException ex) { assertTrue(ex.toString(), ex.getExceptions().get(1) instanceof NullPointerException); } }
public final Single<T> onErrorResumeNext(final Single<? extends T> resumeSingleInCaseOfError) { ObjectHelper.requireNonNull(resumeSingleInCaseOfError, "resumeSingleInCaseOfError is null"); return onErrorResumeNext(Functions.justFunction(resumeSingleInCaseOfError));
@Test public void resumeSuccess() { Single.just(1) .onErrorResumeNext(Single.just(2)) .test() .assertResult(1); } }
@Test public void resumeDispose() { TestHelper.checkDisposed(Single.error(new TestException("Main")) .onErrorResumeNext(Single.just(1))); }
@Test public void onErrorResumeNext() { Single.<Integer>error(new TestException()) .onErrorResumeNext(Single.just(1)) .test() .assertResult(1); }
@Test public void resumeErrors() { Single.error(new TestException("Main")) .onErrorResumeNext(Single.error(new TestException("Resume"))) .test() .assertFailureAndMessage(TestException.class, "Resume"); }
public static Single<Bitmap> combineBitmaps (final Context context, final List<String> urls) { return Single.create(e -> { final ArrayList<Bitmap> bitmaps = new ArrayList<>(); ArrayList<Single<Bitmap>> singles = new ArrayList<>(); for(String url : urls) { if(singles.size() >= 4) { break; } singles.add(bitmapForURL(context, url).onErrorResumeNext(throwable -> null)); } Single.merge(singles).observeOn(AndroidSchedulers.mainThread()) .doOnComplete(() -> { int size = context.getResources().getDimensionPixelSize(R.dimen.chat_sdk_chat_action_barcircle_image_view_size); Bitmap bitmap = ImageUtils.getMixImagesBitmap(size, size, bitmaps); if(bitmap == null) { e.onError(new Throwable(context.getString(R.string.thread_image_could_not_be_created))); } else { e.onSuccess(bitmap); } }) .subscribe(bitmaps::add, throwable -> { e.onError(throwable); ChatSDK.logError(throwable); }); }); }
@Override public Single<Page<User>> findByDomain(String domain, int page, int size) { LOGGER.debug("Find users by domain: {}", domain); return userRepository.findByDomain(domain, page, size) .onErrorResumeNext(ex -> { LOGGER.error("An error occurs while trying to find users by domain {}", domain, ex); return Single.error(new TechnicalManagementException(String.format("An error occurs while trying to find users by domain %s", domain), ex)); }); }
@Override public Single<List<Group>> findByMember(String memberId) { LOGGER.debug("Find groups by member : {}", memberId); return groupRepository.findByMember(memberId) .map(groups -> groups.stream().map(group -> convert(group, null, true)).collect(Collectors.toList())) .onErrorResumeNext(ex -> { LOGGER.error("An error occurs while trying to find a groups using member ", memberId, ex); return Single.error(new TechnicalManagementException( String.format("An error occurs while trying to find a user using member: %s", memberId), ex)); }); }
@Override public Single<Page<Client>> findAll(int page, int size) { LOGGER.debug("Find clients"); return clientRepository.findAll(page, size) .onErrorResumeNext(ex -> { LOGGER.error("An error occurs while trying to find clients", ex); return Single.error(new TechnicalManagementException("An error occurs while trying to find clients", ex)); }); }
@Override public Single<Set<Domain>> findByIdIn(Collection<String> ids) { LOGGER.debug("Find domains by id in {}", ids); return domainRepository.findByIdIn(ids) .onErrorResumeNext(ex -> { LOGGER.error("An error occurs while trying to find domains by id in {}", ids, ex); return Single.error(new TechnicalManagementException("An error occurs while trying to find domains by id in", ex)); }); }
static <T> Single<T> addErrorWrappingToSingle(Single<T> s) { return s.onErrorResumeNext(e -> { if (e instanceof StorageErrorException) { return Single.error(new StorageException((StorageErrorException) e)); } return Single.error(e); }); } }
/** * Read from cache and throw if no data is available. */ public final Single<T> read() { return Single.defer(() -> Single.fromObservable(builder.processorProviders .<T>process(getConfigProvider(exceptionAdapter.placeholderLoader(), new EvictDynamicKey(false), false, null)))) .onErrorResumeNext(exceptionAdapter::stripPlaceholderLoaderException); }
@Override public Maybe<Token> getRefreshToken(String refreshToken, Client client) { return jwtService.decodeAndVerify(refreshToken, client) .onErrorResumeNext(ex -> { if (ex instanceof JwtException) { return Single.error(new InvalidTokenException(ex.getMessage(), ex)); } return Single.error(ex); }) .flatMapMaybe(jwt -> refreshTokenRepository.findByToken(jwt.getJti()).map(refreshToken1 -> convertRefreshToken(jwt))); }
private Single<Wallet> passwordVerification(Wallet wallet, String masterPassword) { return passwordStore .getPassword(wallet) .flatMap(password -> walletRepository .exportWallet(wallet, password, password) .flatMap(keyStore -> walletRepository.findWallet(wallet.address))) .onErrorResumeNext(throwable -> walletRepository .deleteWallet(wallet.address, masterPassword) .lift(completableErrorProxy(throwable)) .toSingle(() -> wallet)); } }