@Test(expected = NullPointerException.class) public void composeNull() { Maybe.just(1).compose(null); }
@Test public void maybeGenericsSignatureTest() { A<String, Integer> a = new A<String, Integer>() { }; Maybe.just(a).compose(TransformerTest.<String>testMaybeTransformerCreator()); }
@Test public void compose() { Maybe.just(1).compose(new MaybeTransformer<Integer, Integer>() { @Override public MaybeSource<Integer> apply(Maybe<Integer> m) { return m.map(new Function<Integer, Integer>() { @Override public Integer apply(Integer w) throws Exception { return w + 1; } }); } }) .test() .assertResult(2); }
@Test public void maybeTransformerThrows() { try { Maybe.just(1).compose(new MaybeTransformer<Integer, Integer>() { @Override public Maybe<Integer> apply(Maybe<Integer> v) { throw new TestException("Forced failure"); } }); fail("Should have thrown!"); } catch (TestException ex) { assertEquals("Forced failure", ex.getMessage()); } }
@Test public void noEvents() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bindUntilEvent(lifecycle, "stop")) .test(); subject.onNext("1"); testObserver.assertValue("1"); testObserver.assertComplete(); }
@Test public void noEvent() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bind(lifecycle)) .test(); stream.onNext("1"); testObserver.assertValue("1"); testObserver.assertComplete(); }
@Test public void noEvents() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bind(lifecycle, CORRESPONDING_EVENTS)) .test(); subject.onNext("1"); testObserver.assertValue("1"); testObserver.assertComplete(); }
@Test public void oneStartEvent() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bind(lifecycle, CORRESPONDING_EVENTS)) .test(); lifecycle.onNext("create"); subject.onNext("1"); testObserver.assertValue("1"); testObserver.assertComplete(); }
@Test public void oneWrongEvent() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bindUntilEvent(lifecycle, "stop")) .test(); lifecycle.onNext("keep going"); subject.onNext("1"); testObserver.assertValue("1"); testObserver.assertComplete(); }
@Test public void oneEvent() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bind(lifecycle)) .test(); lifecycle.onNext("stop"); stream.onNext("1"); testObserver.assertNoValues(); testObserver.assertComplete(); } }
@Test public void twoOpenEvents() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bind(lifecycle, CORRESPONDING_EVENTS)) .test(); lifecycle.onNext("create"); lifecycle.onNext("start"); subject.onNext("1"); testObserver.assertValue("1"); testObserver.assertComplete(); }
@Test public void openAndCloseEvent() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bind(lifecycle, CORRESPONDING_EVENTS)) .test(); lifecycle.onNext("create"); lifecycle.onNext("destroy"); subject.onNext("1"); testObserver.assertNoValues(); testObserver.assertComplete(); }
@Test public void twoEvents() { TestObserver<String> testObserver = maybe .compose(RxLifecycle.<String, String>bindUntilEvent(lifecycle, "stop")) .test(); lifecycle.onNext("keep going"); lifecycle.onNext("stop"); subject.onNext("1"); testObserver.assertNoValues(); testObserver.assertComplete(); }
static <T> void testMaybeMapFromBuffer(String json, MaybeTransformer<Buffer, ? extends T> transformer, T expected) throws Exception { Maybe<Buffer> stream = Maybe.just(Buffer.buffer(json)); Maybe<T> mapped = stream.compose(transformer); List<T> items = new ArrayList<>(); List<Throwable> errors = new ArrayList<>(); AtomicInteger completions = new AtomicInteger(); mapped.subscribe(items::add, errors::add, completions::incrementAndGet); Assert.assertEquals(Collections.singletonList(expected), items); Assert.assertEquals(Collections.emptyList(), errors); Assert.assertEquals(0, completions.get()); }
private void testMaybe() { Maybe.timer(3, TimeUnit.SECONDS) .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .compose(RxLifecycle.bind(this).<Long>disposeMaybeWhen(LifecycleEvent.DESTROY_VIEW)) .subscribe(new Consumer<Long>() { @Override public void accept(Long n) throws Exception { toast("Maybe -> onSuccess()"); } }); }
private void testMaybeMapPojoFromBufferFailure(Maybe<Buffer> stream, MaybeTransformer<Buffer, SimplePojo> transformer) throws Exception { Maybe<SimplePojo> mapped = stream.compose(transformer); TestSubscriber<SimplePojo> subscriber = new TestSubscriber<>(); TestUtils.subscribe(mapped, subscriber); subscriber .assertError(err -> assertTrue(err instanceof JsonParseException)) .assertEmpty(); }
@Test public void mapOptionalError() { Maybe.<Integer>error(new IllegalArgumentException()) .compose(MaybeInterop.mapOptional(v -> Optional.of(-v))) .test() .assertFailure(IllegalArgumentException.class); }
@Test public void disposed() { TestHelper.checkDisposed( Maybe.fromCallable(() -> 1) .compose(MaybeInterop.mapOptional(v -> Optional.of(v))) ); }
@Test public void mapOptional() { Maybe.just(1) .compose(MaybeInterop.mapOptional(v -> Optional.of(-v))) .test() .assertResult(-1); }
private void testMaybeMapFromEmptyBuffer(MaybeTransformer<Buffer, SimplePojo> transformer) throws Exception { Maybe<Buffer> stream = Maybe.empty(); Maybe<SimplePojo> mapped = stream.compose(transformer); TestSubscriber<SimplePojo> subscriber = new TestSubscriber<SimplePojo>().prefetch(0); TestUtils.subscribe(mapped, subscriber); subscriber .assertCompleted() .assertEmpty(); }