@Override public SingleSource<Object> apply(Single<Object> s) throws Exception { return s.flatMap(new Function<Object, SingleSource<? extends Object>>() { @Override public SingleSource<? extends Object> apply(Object v) throws Exception { return Single.just(v); } }); } });
@Override public Single<byte[]> readCharacteristic(@NonNull UUID characteristicUuid) { return getCharacteristic(characteristicUuid) .flatMap(new Function<BluetoothGattCharacteristic, SingleSource<? extends byte[]>>() { @Override public SingleSource<? extends byte[]> apply(BluetoothGattCharacteristic characteristic) { return readCharacteristic(characteristic); } }); }
@Override public LongWriteOperationBuilder setCharacteristicUuid(@NonNull final UUID uuid) { bluetoothGattCharacteristicObservable = discoverServices().flatMap( new Function<RxBleDeviceServices, SingleSource<BluetoothGattCharacteristic>>() { @Override public SingleSource<BluetoothGattCharacteristic> apply(RxBleDeviceServices rxBleDeviceServices) { return rxBleDeviceServices.getCharacteristic(uuid); } } ); return this; }
@Test(expected = NullPointerException.class) public void flatMapNull() { just1.flatMap(null); }
@Test(expected = NullPointerException.class) public void flatMapNull() { Single.just(1) .flatMap(null); }
@Test(expected = NullPointerException.class) public void flatMapFunctionReturnsNull() { just1.flatMap(new Function<Integer, Single<Object>>() { @Override public Single<Object> apply(Integer v) { return null; } }).blockingGet(); }
@Override protected Single<List<Repository>> loadData(boolean forceRefresh) { User org = this.org.get(); if (org == null) { return Single.just(Collections.emptyList()); } return Single.fromCallable(() -> cache.getRepos(org, forceRefresh)) .flatMap(repos -> Observable.fromIterable(repos) .sorted(recentRepos) .toList()); }
@Test public void flatMapError() { RuntimeException exception = new RuntimeException("test"); Single.error(exception).flatMap(new Function<Object, SingleSource<Object>>() { @Override public SingleSource<Object> apply(final Object integer) throws Exception { return Single.just(new Object()); } }) .test() .assertError(exception); }
@Override protected Single<List<IssueFilter>> loadData(boolean forceRefresh) { return Single.fromCallable(() -> new ArrayList<>(cache.getIssueFilters())) .flatMap(filters -> Observable.fromIterable(filters) .sorted(FilterListFragment.this) .toList()); }
@Test public void dispose() { TestHelper.checkDisposed(Single.just(1).flatMap(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(2); } })); }
/** * Refresh the fragment's list. */ protected void refresh(boolean force) { if (!isAdded() || isLoading) { return; } if (dataLoadDisposable != null && !dataLoadDisposable.isDisposed()) { dataLoadDisposable.dispose(); } isLoading = true; dataLoadDisposable = loadData(force) .flatMap(items -> Observable.fromIterable(items) .map(this::createItem) .toList()) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .as(AutoDisposeUtils.bindToLifecycle(this)) .subscribe(this::onDataLoaded, this::onDataLoadError); }
@Test public void mappedSingleOnError() { Single.just(1).flatMap(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.error(new TestException()); } }) .test() .assertFailure(TestException.class); }
@Test public void flatMapValue() { Single.just(1).flatMap(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { if (integer == 1) { return Single.just(2); } return Single.just(1); } }) .test() .assertResult(2); }
@Test public void flatMapValueDifferentType() { Single.just(1).flatMap(new Function<Integer, SingleSource<String>>() { @Override public SingleSource<String> apply(final Integer integer) throws Exception { if (integer == 1) { return Single.just("2"); } return Single.just("1"); } }) .test() .assertResult("2"); }
@Test public void flatMapValueErrorThrown() { Single.just(1).flatMap(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { throw new RuntimeException("something went terribly wrong!"); } }) .test() .assertNoValues() .assertError(RuntimeException.class) .assertErrorMessage("something went terribly wrong!"); }
private static Single<String> nestSingle(String input) { RequestContext.current(); return single(input).flatMap(RequestContextAssemblyTest::single); }
@Test public void singleSingle() throws Exception { List<Throwable> errors = TestHelper.trackPluginErrors(); try { TestObserver<Integer> to = Single.just(1) .subscribeOn(Schedulers.io()) .flatMap(new Function<Integer, Single<Integer>>() { @Override public Single<Integer> apply(Integer v) throws Exception { sleep(); return Single.<Integer>error(new TestException()); } }) .test(); cb.await(); beforeCancelSleep(to); to.cancel(); Thread.sleep(SLEEP_AFTER_CANCEL); to.assertEmpty(); assertTrue(errors.toString(), errors.isEmpty()); } finally { RxJavaPlugins.reset(); } }
public Single<FullTree> refresh() { GitService gitService = ServiceGenerator.createService(context, GitService.class); return getBranch(reference) .map(branch -> branch.replace("heads/", "")) .flatMap(branch -> getValidRef(gitService, reference, branch)) .flatMap(reference -> gitService.getGitCommit(repo.owner().login(), repo.name(), reference.object().sha()) .map(Response::body) .zipWith(Single.just(reference), RefreshTreeModel::new)) .flatMap(model -> gitService.getGitTreeRecursive(repo.owner().login(), repo.name(), model.getCommit().tree().sha()) .map(Response::body) .zipWith(Single.just(model.ref), FullTree::new)); }
@Test public void flatMapValueNull() { Single.just(1).flatMap(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { return null; } }) .test() .assertNoValues() .assertError(NullPointerException.class) .assertErrorMessage("The single returned by the mapper is null"); }
@Test public void testFlatMap() { TestSubscriber<String> ts = new TestSubscriber<String>(); Single.just("Hello").flatMap(new Function<String, Single<String>>() { @Override public Single<String> apply(String s) { return Single.just(s + " World!").subscribeOn(Schedulers.computation()); } } ).toFlowable().subscribe(ts); if (!ts.awaitTerminalEvent(5, TimeUnit.SECONDS)) { ts.cancel(); Assert.fail("TestSubscriber timed out."); } ts.assertValueSequence(Arrays.asList("Hello World!")); }