@Test(expected = NullPointerException.class) public void doOnSuccess() { just1.doOnSuccess(null); }
@PostMapping("/flowable") @SuppressWarnings("deprecation") public io.reactivex.Completable createWithFlowable(@RequestBody Flowable<Person> flowable) { return flowable.toList().doOnSuccess(persons::addAll).toCompletable(); } }
@PostMapping("/rxjava2-observable") @SuppressWarnings("deprecation") public io.reactivex.Completable createWithRxJava2Observable( @RequestBody io.reactivex.Observable<Person> observable) { return observable.toList().doOnSuccess(persons::addAll).toCompletable(); }
@Override public SingleSource<Integer> apply(Integer v) throws Exception { if (v == 0) { return Single.error(new RuntimeException()); } else { return Single.just(1).doOnSuccess(new Consumer<Integer>() { @Override public void accept(Integer n) throws Exception { completed.set(true); }}); } } })
@Override protected Single<RxBleDeviceServices> getCallback(RxBleGattCallback rxBleGattCallback) { return rxBleGattCallback.getOnServicesDiscovered().firstOrError() .doOnSuccess(new Consumer<RxBleDeviceServices>() { @Override public void accept(RxBleDeviceServices rxBleDeviceServices) throws Exception { bleServicesLogger.log(rxBleDeviceServices, bluetoothGatt.getDevice()); } }); }
@Test public void testTakeWhileToList() { final int expectedCount = 3; final AtomicInteger count = new AtomicInteger(); for (int i = 0; i < expectedCount; i++) { Observable .just(Boolean.TRUE, Boolean.FALSE) .takeWhile(new Predicate<Boolean>() { @Override public boolean test(Boolean v) { return v; } }) .toList() .doOnSuccess(new Consumer<List<Boolean>>() { @Override public void accept(List<Boolean> booleans) { count.incrementAndGet(); } }) .subscribe(); } assertEquals(expectedCount, count.get()); }
@Test public void testIssue1451Case1() { // https://github.com/Netflix/RxJava/issues/1451 final int expectedCount = 3; final AtomicInteger count = new AtomicInteger(); for (int i = 0; i < expectedCount; i++) { Observable .just(Boolean.TRUE, Boolean.FALSE) .takeWhile(new Predicate<Boolean>() { @Override public boolean test(Boolean value) { return value; } }) .toList() .doOnSuccess(new Consumer<List<Boolean>>() { @Override public void accept(List<Boolean> booleans) { count.incrementAndGet(); } }) .subscribe(); } assertEquals(expectedCount, count.get()); }
@Test public void testIssue1451Case2() { // https://github.com/Netflix/RxJava/issues/1451 final int expectedCount = 3; final AtomicInteger count = new AtomicInteger(); for (int i = 0; i < expectedCount; i++) { Observable .just(Boolean.TRUE, Boolean.FALSE, Boolean.FALSE) .takeWhile(new Predicate<Boolean>() { @Override public boolean test(Boolean value) { return value; } }) .toList() .doOnSuccess(new Consumer<List<Boolean>>() { @Override public void accept(List<Boolean> booleans) { count.incrementAndGet(); } }) .subscribe(); } assertEquals(expectedCount, count.get()); }
@Test public void testTakeWhileToList() { final int expectedCount = 3; final AtomicInteger count = new AtomicInteger(); for (int i = 0; i < expectedCount; i++) { Flowable .just(Boolean.TRUE, Boolean.FALSE) .takeWhile(new Predicate<Boolean>() { @Override public boolean test(Boolean v) { return v; } }) .toList() .doOnSuccess(new Consumer<List<Boolean>>() { @Override public void accept(List<Boolean> booleans) { count.incrementAndGet(); } }) .subscribe(); } assertEquals(expectedCount, count.get()); }
@Test public void testIssue1451Case2() { // https://github.com/Netflix/RxJava/issues/1451 final int expectedCount = 3; final AtomicInteger count = new AtomicInteger(); for (int i = 0; i < expectedCount; i++) { Flowable .just(Boolean.TRUE, Boolean.FALSE, Boolean.FALSE) .takeWhile(new Predicate<Boolean>() { @Override public boolean test(Boolean value) { return value; } }) .toList() .doOnSuccess(new Consumer<List<Boolean>>() { @Override public void accept(List<Boolean> booleans) { count.incrementAndGet(); } }) .subscribe(); } assertEquals(expectedCount, count.get()); }
@Test public void testIssue1451Case1() { // https://github.com/Netflix/RxJava/issues/1451 final int expectedCount = 3; final AtomicInteger count = new AtomicInteger(); for (int i = 0; i < expectedCount; i++) { Flowable .just(Boolean.TRUE, Boolean.FALSE) .takeWhile(new Predicate<Boolean>() { @Override public boolean test(Boolean value) { return value; } }) .toList() .doOnSuccess(new Consumer<List<Boolean>>() { @Override public void accept(List<Boolean> booleans) { count.incrementAndGet(); } }) .subscribe(); } assertEquals(expectedCount, count.get()); }
@Ignore("v2 components should not throw") @Test(expected = RuntimeException.class) public void testOnErrorExceptionIsThrownFromSingleDoOnSuccess() throws Exception { Single.just(1) .doOnSuccess(new Consumer<Integer>() { @Override public void accept(Integer integer) { throw new RuntimeException(); } }) .toObservable().subscribe(new OnErrorFailedSubscriber()); }
@Test public void doOnSuccessCrash() { Single.just(1) .doOnSuccess(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { throw new TestException(); } }) .test() .assertFailure(TestException.class); }
@Test public void doOnSuccess() { final Object[] event = { null }; Single.just(1).doOnSuccess(new Consumer<Integer>() { @Override public void accept(Integer e) throws Exception { event[0] = e; } }) .test(); assertEquals(1, event[0]); }
@Test public void repeatUntil() { final AtomicBoolean flag = new AtomicBoolean(); Single.just(1) .doOnSuccess(new Consumer<Integer>() { int c; @Override public void accept(Integer v) throws Exception { if (++c == 5) { flag.set(true); } } }) .repeatUntil(new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return flag.get(); } }) .test() .assertResult(1, 1, 1, 1, 1); }
.doOnSuccess(new Consumer<List<Object>>() { @Override public void accept(List<Object> integers) {
.doOnSuccess(new Consumer<List<Object>>() { @Override public void accept(List<Object> integers) {
@Test public void doOnSuccessErrors() { final int[] call = { 0 }; Single.error(new TestException()) .doOnSuccess(new Consumer<Object>() { @Override public void accept(Object v) throws Exception { call[0]++; } }) .test() .assertFailure(TestException.class); assertEquals(0, call[0]); }
public static <U> SingleTransformer<U, U> bindToLifecycle(Context context, CharSequence message) { return upstream -> { final MaterialDialog progressDialog = new MaterialDialog.Builder(context) .content(message) .progress(true, 0) .build(); return upstream .doOnSubscribe(disposable -> progressDialog.show()) .doOnSuccess(u -> progressDialog.dismiss()) .doOnError(throwable -> progressDialog.dismiss()); }; } }
/** * Check if we can load it from the cache (forceLoad parameter), if we can't, * load from the network (Single loadFromNetwork) * and put the results in the cache. */ private static <I extends Info> Single<I> checkCache(boolean forceLoad, int serviceId, String url, Single<I> loadFromNetwork) { checkServiceId(serviceId); loadFromNetwork = loadFromNetwork.doOnSuccess(info -> cache.putInfo(serviceId, url, info)); Single<I> load; if (forceLoad) { cache.removeInfo(serviceId, url); load = loadFromNetwork; } else { load = Maybe.concat(ExtractorHelper.loadFromCache(serviceId, url), loadFromNetwork.toMaybe()) .firstElement() //Take the first valid .toSingle(); } return load; }