@Test(expected = NullPointerException.class) public void nullArgument() { Completable.create(null); }
/** * Converts an {@link ApolloPrefetch} to a synchronous Completable * * @param prefetch the ApolloPrefetch to convert * @return the converted Completable * @throws NullPointerException if prefetch == null */ @NotNull public static Completable from(@NotNull final ApolloPrefetch prefetch) { checkNotNull(prefetch, "prefetch == null"); return Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(final CompletableEmitter emitter) { cancelOnCompletableDisposed(emitter, prefetch); prefetch.enqueue(new ApolloPrefetch.Callback() { @Override public void onSuccess() { if (!emitter.isDisposed()) { emitter.onComplete(); } } @Override public void onFailure(@NotNull ApolloException e) { Exceptions.throwIfFatal(e); if (!emitter.isDisposed()) { emitter.onError(e); } } }); } }); }
@Test public void onErrorThrows2() { Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { try { e.onError(new IOException()); fail("Should have thrown"); } catch (TestException ex) { // expected } assertTrue(e.isDisposed()); } }).subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { } @Override public void onError(Throwable e) { throw new TestException(); } @Override public void onComplete() { } }); }
@Test public void onCompleteThrows2() { Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { try { e.onComplete(); fail("Should have thrown"); } catch (TestException ex) { // expected } assertTrue(e.isDisposed()); } }).subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { } @Override public void onError(Throwable e) { } @Override public void onComplete() { throw new TestException(); } }); }
@Test public void dispose() { TestHelper.checkDisposed(Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { e.onComplete(); } })); }
@Test public void onCompleteThrows() { Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { Disposable d = Disposables.empty(); e.setDisposable(d); try { e.onComplete(); fail("Should have thrown"); } catch (TestException ex) { // expected } assertTrue(d.isDisposed()); assertTrue(e.isDisposed()); } }).subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { } @Override public void onError(Throwable e) { } @Override public void onComplete() { throw new TestException(); } }); }
@Test public void onErrorThrows() { Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { Disposable d = Disposables.empty(); e.setDisposable(d); try { e.onError(new IOException()); fail("Should have thrown"); } catch (TestException ex) { // expected } assertTrue(d.isDisposed()); assertTrue(e.isDisposed()); } }).subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { } @Override public void onError(Throwable e) { throw new TestException(); } @Override public void onComplete() { } }); }
@Test public void callbackThrows() { Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { throw new TestException(); } }) .test() .assertFailure(TestException.class); }
@Test public void onErrorNull() { Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { e.onError(null); } }) .test() .assertFailure(NullPointerException.class); }
@Test public void emitterHasToString() { Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter emitter) throws Exception { assertTrue(emitter.toString().contains(CompletableCreate.Emitter.class.getSimpleName())); } }).test().assertEmpty(); } }
return Completable.create(new CompletableOnSubscribe() {
@Test public void tryOnError() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Boolean[] response = { null }; Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { e.onComplete(); response[0] = e.tryOnError(new TestException()); } }) .test() .assertResult(); assertFalse(response[0]); assertTrue(errors.toString(), errors.isEmpty()); } finally { RxJavaPlugins.reset(); } }
private static Completable completable(String input) { RequestContext.current(); return Completable.create(emitter -> { RequestContext.current(); emitter.onComplete(); }); }
@Test public void verifyCancellation() { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java Completable source = Completable.create(e -> e.setCancellable(i::incrementAndGet)); CompletableSubject scope = CompletableSubject.create(); source.as(autoDisposable(scope)) .subscribe(); assertThat(i.get()).isEqualTo(0); assertThat(scope.hasObservers()).isTrue(); scope.onComplete(); // Verify cancellation was called assertThat(i.get()).isEqualTo(1); assertThat(scope.hasObservers()).isFalse(); }
@Test public void basicWithError() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d = Disposables.empty(); Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { e.setDisposable(d); e.onError(new TestException()); e.onComplete(); e.onError(new TestException("second")); } }) .test() .assertFailure(TestException.class); assertTrue(d.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class, "second"); } finally { RxJavaPlugins.reset(); } }
@Test public void basic() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d = Disposables.empty(); Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { e.setDisposable(d); e.onComplete(); e.onError(new TestException()); e.onComplete(); } }) .test() .assertResult(); assertTrue(d.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaPlugins.reset(); } }
@Test public void basicWithCancellable() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { final Disposable d1 = Disposables.empty(); final Disposable d2 = Disposables.empty(); Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { e.setDisposable(d1); e.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { d2.dispose(); } }); e.onComplete(); e.onError(new TestException()); e.onComplete(); } }) .test() .assertResult(); assertTrue(d1.isDisposed()); assertTrue(d2.isDisposed()); TestHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaPlugins.reset(); } }
public Completable start () { return Completable.create(e -> { Completable timer = Completable.timer(200, TimeUnit.MILLISECONDS); delayStartDisposable = timer.subscribe(() -> { startRecording(); e.onComplete(); }); }); }
public Completable userOn(final User user) { return Completable.create(e -> { final UserWrapper wrapper = new UserWrapper(user); disposableList.add(wrapper.onlineOn().doOnDispose(wrapper::onlineOff).subscribe(aBoolean -> { ChatSDK.events().source().onNext(NetworkEvent.userPresenceUpdated(user)); }, e::onError)); disposableList.add(wrapper.metaOn().doOnDispose(wrapper::metaOff).subscribe(user1 -> { ChatSDK.events().source().onNext(NetworkEvent.userMetaUpdated(user1)); e.onComplete(); }, e::onError)); }); }
public Completable once () { return Completable.create(e -> { DatabaseReference detailsRef = FirebasePaths.threadDetailsRef(model.getEntityID()); detailsRef.addValueEventListener(new FirebaseEventListener().onValue((snapshot, hasValue) -> { if(hasValue && snapshot.getValue() instanceof Map) { deserialize((Map<String, Object>) snapshot.getValue()); } e.onComplete(); })); }).subscribeOn(Schedulers.single()); }