@Test(expected = NullPointerException.class) public void nullArgument() { Maybe.create(null); }
@Test(expected = NullPointerException.class) public void nullArgument() { Maybe.create(null); }
@Test public void dispose() { TestHelper.checkDisposed(Maybe.create(new MaybeOnSubscribe<Object>() { @Override public void subscribe(MaybeEmitter<Object> e) throws Exception { e.onSuccess(1); } })); }
@Test public void onErrorThrows2() { Maybe.create(new MaybeOnSubscribe<Object>() { @Override public void subscribe(MaybeEmitter<Object> e) throws Exception { try { e.onError(new IOException()); fail("Should have thrown"); } catch (TestException ex) { // expected } assertTrue(e.isDisposed()); } }).subscribe(new MaybeObserver<Object>() { @Override public void onSubscribe(Disposable d) { } @Override public void onSuccess(Object value) { } @Override public void onError(Throwable e) { throw new TestException(); } @Override public void onComplete() { } }); }
@Test public void onCompleteThrows2() { Maybe.create(new MaybeOnSubscribe<Object>() { @Override public void subscribe(MaybeEmitter<Object> e) throws Exception { try { e.onComplete(); fail("Should have thrown"); } catch (TestException ex) { // expected } assertTrue(e.isDisposed()); } }).subscribe(new MaybeObserver<Object>() { @Override public void onSubscribe(Disposable d) { } @Override public void onSuccess(Object value) { } @Override public void onError(Throwable e) { } @Override public void onComplete() { throw new TestException(); } }); }
@Test public void callbackThrows() { Maybe.create(new MaybeOnSubscribe<Object>() { @Override public void subscribe(MaybeEmitter<Object> e) throws Exception { throw new TestException(); } }) .test() .assertFailure(TestException.class); }
@Test public void onSuccessNull() { Maybe.create(new MaybeOnSubscribe<Object>() { @Override public void subscribe(MaybeEmitter<Object> e) throws Exception { e.onSuccess(null); } }) .test() .assertFailure(NullPointerException.class); }
@Test public void onErrorNull() { Maybe.create(new MaybeOnSubscribe<Object>() { @Override public void subscribe(MaybeEmitter<Object> e) throws Exception { e.onError(null); } }) .test() .assertFailure(NullPointerException.class); }
@Test public void emitterHasToString() { Maybe.create(new MaybeOnSubscribe<Object>() { @Override public void subscribe(MaybeEmitter<Object> emitter) throws Exception { assertTrue(emitter.toString().contains(MaybeCreate.Emitter.class.getSimpleName())); } }).test().assertEmpty(); } }
@SuppressWarnings("unchecked") @Test public void noSubsequentSubscription() { final int[] calls = { 0 }; Maybe<Integer> source = Maybe.create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> s) throws Exception { calls[0]++; s.onSuccess(1); } }); Maybe.concat(Arrays.asList(source, source)).firstElement() .test() .assertResult(1); assertEquals(1, calls[0]); }
@SuppressWarnings("unchecked") @Test public void noSubsequentSubscriptionDelayError() { final int[] calls = { 0 }; Maybe<Integer> source = Maybe.create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> s) throws Exception { calls[0]++; s.onSuccess(1); } }); Maybe.concatDelayError(Arrays.asList(source, source)).firstElement() .test() .assertResult(1); assertEquals(1, calls[0]); } }
@Test public void tryOnError() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Boolean[] response = { null }; Maybe.create(new MaybeOnSubscribe<Object>() { @Override public void subscribe(MaybeEmitter<Object> e) throws Exception { e.onSuccess(1); response[0] = e.tryOnError(new TestException()); } }) .test() .assertResult(1); assertFalse(response[0]); assertTrue(errors.toString(), errors.isEmpty()); } finally { RxJavaPlugins.reset(); } }
@SuppressWarnings("unchecked") @Test public void noSubsequentSubscription() { final int[] calls = { 0 }; Maybe<Integer> source = Maybe.create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> s) throws Exception { calls[0]++; s.onSuccess(1); } }); Maybe.concatArray(source, source).firstElement() .test() .assertResult(1); assertEquals(1, calls[0]); }
@SuppressWarnings("unchecked") @Test public void noSubsequentSubscriptionDelayError() { final int[] calls = { 0 }; Maybe<Integer> source = Maybe.create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> s) throws Exception { calls[0]++; s.onSuccess(1); } }); Maybe.concatArrayDelayError(source, source).firstElement() .test() .assertResult(1); assertEquals(1, calls[0]); } }
@Test public void basicWithError() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d = Disposables.empty(); Maybe.<Integer>create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onError(new TestException()); e.onSuccess(2); e.onError(new TestException()); } }).test().assertFailure(TestException.class); assertTrue(d.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaPlugins.reset(); } }
@Test public void basicWithCompletion() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d = Disposables.empty(); Maybe.<Integer>create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onComplete(); e.onSuccess(2); e.onError(new TestException()); } }).test().assertComplete(); assertTrue(d.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaPlugins.reset(); } }
@Test public void basic() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d = Disposables.empty(); Maybe.<Integer>create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onSuccess(1); e.onError(new TestException()); e.onSuccess(2); e.onError(new TestException()); } }).test().assertResult(1); assertTrue(d.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaPlugins.reset(); } }
@Test public void basicWithError() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d = Disposables.empty(); Maybe.<Integer>create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onError(new TestException()); e.onSuccess(2); e.onError(new TestException()); e.onComplete(); } }) .test() .assertFailure(TestException.class); assertTrue(d.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaPlugins.reset(); } }
@Test public void basic() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d = Disposables.empty(); Maybe.<Integer>create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onSuccess(1); e.onError(new TestException()); e.onSuccess(2); e.onError(new TestException()); e.onComplete(); } }) .test() .assertResult(1); assertTrue(d.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class); TestHelper.assertUndeliverable(errors, 1, TestException.class); } finally { RxJavaPlugins.reset(); } }
@Test public void basicWithComplete() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d = Disposables.empty(); Maybe.<Integer>create(new MaybeOnSubscribe<Integer>() { @Override public void subscribe(MaybeEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onComplete(); e.onSuccess(1); e.onError(new TestException()); e.onComplete(); e.onSuccess(2); e.onError(new TestException()); } }) .test() .assertResult(); assertTrue(d.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class); TestHelper.assertUndeliverable(errors, 1, TestException.class); } finally { RxJavaPlugins.reset(); } }