Refine search
private void loadMarkdown(String raw, Repository repo) { MarkdownLoader.load(getActivity(), raw, repo, imageGetter, true) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(rendered -> { bodyText.setText(rendered); showLoading(false); } , e -> ToastUtils.show(getActivity(), R.string.error_rendering_markdown)); } }
@Test public void testMap() { TestSubscriber<String> ts = new TestSubscriber<String>(); Single.just("A") .map(new Function<String, String>() { @Override public String apply(String s) { return s + "B"; } }) .toFlowable().subscribe(ts); ts.assertValueSequence(Arrays.asList("AB")); }
@SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipArrayOneIsNull() { Single.zipArray(new Function<Object[], Object>() { @Override public Object apply(Object[] v) { return 1; } }, Single.just(1), null) .blockingGet(); }
@PostMapping("/rxjava2-single") @SuppressWarnings("deprecation") public io.reactivex.Completable createWithRxJava2Single(@RequestBody io.reactivex.Single<Person> single) { return single.map(persons::add).toCompletable(); }
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(v).subscribeOn(Schedulers.computation()); } }, false, 3)
@Test public void testAsync() { TestSubscriber<String> ts = new TestSubscriber<String>(); Single.just("Hello") .subscribeOn(Schedulers.io()) .map(new Function<String, String>() { @Override public String apply(String v) { System.out.println("SubscribeOn Thread: " + Thread.currentThread()); return v; } }) .observeOn(Schedulers.computation()) .map(new Function<String, String>() { @Override public String apply(String v) { System.out.println("ObserveOn Thread: " + Thread.currentThread()); return v; } }) .toFlowable().subscribe(ts); ts.awaitTerminalEvent(); ts.assertValueSequence(Arrays.asList("Hello")); }
@Test public void testAggregateAsIntSumSourceThrows() { Single<Integer> result = Flowable.concat(Flowable.just(1, 2, 3, 4, 5), Flowable.<Integer> error(new TestException())) .reduce(0, sum).map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver, never()).onSuccess(any()); verify(singleObserver, times(1)).onError(any(TestException.class)); }
@SuppressWarnings("unchecked") @Test public void noWinnerSuccessDispose() throws Exception { for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) { final AtomicBoolean interrupted = new AtomicBoolean(); final CountDownLatch cdl = new CountDownLatch(1); Single.ambArray( Single.just(1) .subscribeOn(Schedulers.single()) .observeOn(Schedulers.computation()), Single.never() ) .subscribe(new BiConsumer<Object, Throwable>() { @Override public void accept(Object v, Throwable e) throws Exception { assertNotNull(v); assertNull(e); interrupted.set(Thread.currentThread().isInterrupted()); cdl.countDown(); } }); assertTrue(cdl.await(500, TimeUnit.SECONDS)); assertFalse("Interrupted!", interrupted.get()); } }
@Test public void testAggregateAsIntSum() { Single<Integer> result = Flowable.just(1, 2, 3, 4, 5).reduce(0, sum) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver).onSuccess(1 + 2 + 3 + 4 + 5); verify(singleObserver, never()).onError(any(Throwable.class)); }
@SuppressWarnings("unchecked") @Test public void noWinnerErrorDispose() throws Exception { final TestException ex = new TestException(); for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) { final AtomicBoolean interrupted = new AtomicBoolean(); final CountDownLatch cdl = new CountDownLatch(1); Single.ambArray( Single.error(ex) .subscribeOn(Schedulers.single()) .observeOn(Schedulers.computation()), Single.never() ) .subscribe(new BiConsumer<Object, Throwable>() { @Override public void accept(Object v, Throwable e) throws Exception { assertNull(v); assertNotNull(e); interrupted.set(Thread.currentThread().isInterrupted()); cdl.countDown(); } }); assertTrue(cdl.await(500, TimeUnit.SECONDS)); assertFalse("Interrupted!", interrupted.get()); } } }
@Test public void testAggregateAsIntSum() { Single<Integer> result = Observable.just(1, 2, 3, 4, 5).reduce(0, sum) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver).onSuccess(1 + 2 + 3 + 4 + 5); verify(singleObserver, never()).onError(any(Throwable.class)); }
@Test public void mapValueErrorThrown() { Single.just(1).map(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!"); }
@Test(timeout = 2000) public void testRepeatTake() { Flowable<Integer> xs = Flowable.just(1, 2); Object[] ys = xs.repeat().subscribeOn(Schedulers.newThread()).take(4).toList().blockingGet().toArray(); assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys); }
@Test public void testSingleOrDefault() { Single<Integer> single = Flowable.just(1).single(2); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(1); inOrder.verifyNoMoreInteractions(); }
@Test public void testToMultimapWithValueSelector() { Flowable<String> source = Flowable.just("a", "b", "cc", "dd"); Single<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc, duplicate); Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>(); expected.put(1, Arrays.asList("aa", "bb")); expected.put(2, Arrays.asList("cccc", "dddd")); mapped.subscribe(singleObserver); verify(singleObserver, never()).onError(any(Throwable.class)); verify(singleObserver, times(1)).onSuccess(expected); }
@Test public void testIsEmptyWithTwoItems() { Flowable<Integer> w = Flowable.just(1, 2); Single<Boolean> single = w.isEmpty(); SingleObserver<Boolean> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); verify(observer, never()).onSuccess(true); verify(observer, times(1)).onSuccess(false); verify(observer, never()).onError(any(Throwable.class)); }
@Test public void testListViaFlowable() { Flowable<String> w = Flowable.fromIterable(Arrays.asList("one", "two", "three")); Single<List<String>> single = w.toList(); SingleObserver<List<String>> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); verify(observer, times(1)).onSuccess(Arrays.asList("one", "two", "three")); verify(observer, Mockito.never()).onError(any(Throwable.class)); }