target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@SuppressWarnings("unchecked") @Test public void scalarCallable() { Maybe<Integer> m = Maybe.just(1); assertTrue(m.getClass().toString(), m instanceof ScalarCallable); assertEquals(1, ((ScalarCallable<Integer>)m).call().intValue()); } | @Override public T call() { return value; } | MaybeJust extends Maybe<T> implements ScalarCallable<T> { @Override public T call() { return value; } } | MaybeJust extends Maybe<T> implements ScalarCallable<T> { @Override public T call() { return value; } MaybeJust(T value); } | MaybeJust extends Maybe<T> implements ScalarCallable<T> { @Override public T call() { return value; } MaybeJust(T value); @Override T call(); } | MaybeJust extends Maybe<T> implements ScalarCallable<T> { @Override public T call() { return value; } MaybeJust(T value); @Override T call(); } |
@Test public void onlineSuccess() { PublishSubject<Integer> pp = PublishSubject.create(); Maybe<Integer> source = pp.singleElement().cache(); assertFalse(pp.hasObservers()); assertNotNull(((MaybeCache<Integer>)source).source.get()); TestObserver<Integer> ts = source.test(); assertNull(((MaybeCache<Integer>)source).sour... | @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... |
@Test public void onlineError() { PublishSubject<Integer> pp = PublishSubject.create(); Maybe<Integer> source = pp.singleElement().cache(); assertFalse(pp.hasObservers()); assertNotNull(((MaybeCache<Integer>)source).source.get()); TestObserver<Integer> ts = source.test(); assertNull(((MaybeCache<Integer>)source).source... | @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } @SuppressWarnings("unchecked") MaybeCache(Ma... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } @SuppressWarnings("unchecked") MaybeCache(Ma... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } @SuppressWarnings("unchecked") MaybeCache(Ma... |
@Test public void onlineComplete() { PublishSubject<Integer> pp = PublishSubject.create(); Maybe<Integer> source = pp.singleElement().cache(); assertFalse(pp.hasObservers()); assertNotNull(((MaybeCache<Integer>)source).source.get()); TestObserver<Integer> ts = source.test(); assertNull(((MaybeCache<Integer>)source).sou... | @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... |
@Test public void crossCancelOnSuccess() { final TestObserver<Integer> ts = new TestObserver<Integer>(); PublishSubject<Integer> pp = PublishSubject.create(); Maybe<Integer> source = pp.singleElement().cache(); source.subscribe(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { ts.canc... | @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... |
@Test public void crossCancelOnError() { final TestObserver<Integer> ts = new TestObserver<Integer>(); PublishSubject<Integer> pp = PublishSubject.create(); Maybe<Integer> source = pp.singleElement().cache(); source.subscribe(Functions.emptyConsumer(), new Consumer<Object>() { @Override public void accept(Object v) thr... | @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } @SuppressWarnings("unchecked") MaybeCache(Ma... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } @SuppressWarnings("unchecked") MaybeCache(Ma... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onError(Throwable e) { this.error = e; for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onError(e); } } } @SuppressWarnings("unchecked") MaybeCache(Ma... |
@Test public void crossCancelOnComplete() { final TestObserver<Integer> ts = new TestObserver<Integer>(); PublishSubject<Integer> pp = PublishSubject.create(); Maybe<Integer> source = pp.singleElement().cache(); source.subscribe(Functions.emptyConsumer(), Functions.emptyConsumer(), new Action() { @Override public void ... | @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } } | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... | MaybeCache extends Maybe<T> implements MaybeObserver<T> { @SuppressWarnings("unchecked") @Override public void onComplete() { for (CacheDisposable<T> inner : observers.getAndSet(TERMINATED)) { if (!inner.isDisposed()) { inner.actual.onComplete(); } } } @SuppressWarnings("unchecked") MaybeCache(MaybeSource<T> source); ... |
@SuppressWarnings("unchecked") @Test public void callable() throws Exception { final int[] counter = { 0 }; Maybe<Void> m = Maybe.fromRunnable(new Runnable() { @Override public void run() { counter[0]++; } }); assertTrue(m.getClass().toString(), m instanceof Callable); assertNull(((Callable<Void>)m).call()); assertEqua... | @Override public T call() throws Exception { runnable.run(); return null; } | MaybeFromRunnable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { runnable.run(); return null; } } | MaybeFromRunnable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { runnable.run(); return null; } MaybeFromRunnable(Runnable runnable); } | MaybeFromRunnable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { runnable.run(); return null; } MaybeFromRunnable(Runnable runnable); @Override T call(); } | MaybeFromRunnable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { runnable.run(); return null; } MaybeFromRunnable(Runnable runnable); @Override T call(); } |
@Test public void crossDispose() { PublishSubject<Integer> ps = PublishSubject.create(); final TestObserver<Void> ts1 = new TestObserver<Void>(); final TestObserver<Void> ts2 = new TestObserver<Void>() { @Override public void onComplete() { super.onComplete(); ts1.cancel(); } }; Completable c = ps.ignoreElements().cach... | @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Disposable d); @Ove... | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Disposable d); @Ove... |
@Test(timeout = 10000) public void schedulePeriodicallyDirectZeroPeriod() throws Exception { Scheduler s = Schedulers.single(); for (int initial = 0; initial < 2; initial++) { final CountDownLatch cdl = new CountDownLatch(1); final SequentialDisposable sd = new SequentialDisposable(); try { sd.replace(s.schedulePeriodi... | @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); if (period <= 0L) { ScheduledExecutorService exec = executor.get(); InstantPeriodicTask periodicWrapper = new Instant... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); if (period <= 0L) { ScheduledExecutorService exec = executor.get(); InstantPeriod... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); if (period <= 0L) { ScheduledExecutorService exec = executor.get(); InstantPeriod... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); if (period <= 0L) { ScheduledExecutorService exec = executor.get(); InstantPeriod... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); if (period <= 0L) { ScheduledExecutorService exec = executor.get(); InstantPeriod... |
@Test public void crossDisposeOnError() { PublishSubject<Integer> ps = PublishSubject.create(); final TestObserver<Void> ts1 = new TestObserver<Void>(); final TestObserver<Void> ts2 = new TestObserver<Void>() { @Override public void onError(Throwable ex) { super.onError(ex); ts1.cancel(); } }; Completable c = ps.ignore... | @Override public void onError(Throwable e) { error = e; for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onError(e); } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onError(Throwable e) { error = e; for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onError(e); } } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onError(Throwable e) { error = e; for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onError(e); } } } CompletableCache(CompletableSource source); } | CompletableCache extends Completable implements CompletableObserver { @Override public void onError(Throwable e) { error = e; for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onError(e); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Di... | CompletableCache extends Completable implements CompletableObserver { @Override public void onError(Throwable e) { error = e; for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onError(e); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Di... |
@Test public void dispose() { PublishSubject<Integer> ps = PublishSubject.create(); Completable c = ps.ignoreElements().cache(); assertFalse(ps.hasObservers()); TestObserver<Void> ts1 = c.test(); assertTrue(ps.hasObservers()); ts1.cancel(); assertTrue(ps.hasObservers()); TestObserver<Void> ts2 = c.test(); TestObserver<... | @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Disposable d); @Ove... | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Disposable d); @Ove... |
@Test public void subscribeRace() { for (int i = 0; i < 500; i++) { PublishSubject<Integer> ps = PublishSubject.create(); final Completable c = ps.ignoreElements().cache(); final TestObserver<Void> ts1 = new TestObserver<Void>(); final TestObserver<Void> ts2 = new TestObserver<Void>(); Runnable r1 = new Runnable() { @O... | @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Disposable d); @Ove... | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Disposable d); @Ove... |
@Test public void subscribeDisposeRace() { for (int i = 0; i < 500; i++) { PublishSubject<Integer> ps = PublishSubject.create(); final Completable c = ps.ignoreElements().cache(); final TestObserver<Void> ts1 = c.test(); final TestObserver<Void> ts2 = new TestObserver<Void>(); Runnable r1 = new Runnable() { @Override p... | @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); } | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Disposable d); @Ove... | CompletableCache extends Completable implements CompletableObserver { @Override public void onComplete() { for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) { if (!inner.get()) { inner.actual.onComplete(); } } } CompletableCache(CompletableSource source); @Override void onSubscribe(Disposable d); @Ove... |
@Test public void dispose() { MaybeCallbackObserver<Object> mo = new MaybeCallbackObserver<Object>(Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION); Disposable d = Disposables.empty(); mo.onSubscribe(d); assertFalse(mo.isDisposed()); mo.dispose(); assertTrue(mo.isDisposed()); assertTrue(d.i... | @Override public void dispose() { DisposableHelper.dispose(this); } | MaybeCallbackObserver extends AtomicReference<Disposable> implements MaybeObserver<T>, Disposable { @Override public void dispose() { DisposableHelper.dispose(this); } } | MaybeCallbackObserver extends AtomicReference<Disposable> implements MaybeObserver<T>, Disposable { @Override public void dispose() { DisposableHelper.dispose(this); } MaybeCallbackObserver(Consumer<? super T> onSuccess, Consumer<? super Throwable> onError,
Action onComplete); } | MaybeCallbackObserver extends AtomicReference<Disposable> implements MaybeObserver<T>, Disposable { @Override public void dispose() { DisposableHelper.dispose(this); } MaybeCallbackObserver(Consumer<? super T> onSuccess, Consumer<? super Throwable> onError,
Action onComplete); @Override void dispose(); @Ove... | MaybeCallbackObserver extends AtomicReference<Disposable> implements MaybeObserver<T>, Disposable { @Override public void dispose() { DisposableHelper.dispose(this); } MaybeCallbackObserver(Consumer<? super T> onSuccess, Consumer<? super Throwable> onError,
Action onComplete); @Override void dispose(); @Ove... |
@Test public void source() { Completable c = Completable.complete(); assertSame(c, ((HasUpstreamCompletableSource)Maybe.fromCompletable(c)).source()); } | @Override public CompletableSource source() { return source; } | MaybeFromCompletable extends Maybe<T> implements HasUpstreamCompletableSource { @Override public CompletableSource source() { return source; } } | MaybeFromCompletable extends Maybe<T> implements HasUpstreamCompletableSource { @Override public CompletableSource source() { return source; } MaybeFromCompletable(CompletableSource source); } | MaybeFromCompletable extends Maybe<T> implements HasUpstreamCompletableSource { @Override public CompletableSource source() { return source; } MaybeFromCompletable(CompletableSource source); @Override CompletableSource source(); } | MaybeFromCompletable extends Maybe<T> implements HasUpstreamCompletableSource { @Override public CompletableSource source() { return source; } MaybeFromCompletable(CompletableSource source); @Override CompletableSource source(); } |
@Test public void checkDoubleDefaultObserver() { Observer<Integer> consumer = new DefaultObserver<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; Disposable sub1 = Disposables.empty(); consumer.onSubscribe(sub1); assertFal... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test public void checkDoubleDisposableObserver() { Observer<Integer> consumer = new DisposableObserver<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; Disposable sub1 = Disposables.empty(); consumer.onSubscribe(sub1); ass... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test public void checkDoubleResourceObserver() { Observer<Integer> consumer = new ResourceObserver<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; Disposable sub1 = Disposables.empty(); consumer.onSubscribe(sub1); assertF... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test public void checkDoubleDisposableSingleObserver() { SingleObserver<Integer> consumer = new DisposableSingleObserver<Integer>() { @Override public void onSuccess(Integer t) { } @Override public void onError(Throwable t) { } }; Disposable sub1 = Disposables.empty(); consumer.onSubscribe(sub1); assertFalse(sub1.isDi... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test(timeout = 10000) public void schedulePeriodicallyZeroPeriod() throws Exception { Scheduler s = Schedulers.single(); for (int initial = 0; initial < 2; initial++) { final CountDownLatch cdl = new CountDownLatch(1); final SequentialDisposable sd = new SequentialDisposable(); Scheduler.Worker w = s.createWorker(); t... | @NonNull @Override public Worker createWorker() { return new ScheduledWorker(executor.get()); } | SingleScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return new ScheduledWorker(executor.get()); } } | SingleScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return new ScheduledWorker(executor.get()); } SingleScheduler(); SingleScheduler(ThreadFactory threadFactory); } | SingleScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return new ScheduledWorker(executor.get()); } SingleScheduler(); SingleScheduler(ThreadFactory threadFactory); @Override void start(); @Override void shutdown(); @NonNull @Override Worker createWorker(); @NonNull @Override Disposable... | SingleScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return new ScheduledWorker(executor.get()); } SingleScheduler(); SingleScheduler(ThreadFactory threadFactory); @Override void start(); @Override void shutdown(); @NonNull @Override Worker createWorker(); @NonNull @Override Disposable... |
@Test public void checkDoubleResourceSingleObserver() { SingleObserver<Integer> consumer = new ResourceSingleObserver<Integer>() { @Override public void onSuccess(Integer t) { } @Override public void onError(Throwable t) { } }; Disposable sub1 = Disposables.empty(); consumer.onSubscribe(sub1); assertFalse(sub1.isDispos... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test public void checkDoubleDisposableMaybeObserver() { MaybeObserver<Integer> consumer = new DisposableMaybeObserver<Integer>() { @Override public void onSuccess(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; Disposable sub1 = Disposables.empty(); consumer.onSu... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test public void checkDoubleResourceMaybeObserver() { MaybeObserver<Integer> consumer = new ResourceMaybeObserver<Integer>() { @Override public void onSuccess(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; Disposable sub1 = Disposables.empty(); consumer.onSubscr... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test public void checkDoubleDisposableCompletableObserver() { CompletableObserver consumer = new DisposableCompletableObserver() { @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; Disposable sub1 = Disposables.empty(); consumer.onSubscribe(sub1); assertFalse(sub1.isDisposed()); ... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test public void checkDoubleResourceCompletableObserver() { CompletableObserver consumer = new ResourceCompletableObserver() { @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; Disposable sub1 = Disposables.empty(); consumer.onSubscribe(sub1); assertFalse(sub1.isDisposed()); Disp... | public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); } | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... | EndObserverHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private EndObserverHelper(); static boolean validate(... |
@Test public void validateDisposable() { Disposable d1 = Disposables.empty(); assertFalse(EndObserverHelper.validate(DisposableHelper.DISPOSED, d1, getClass())); assertTrue(d1.isDisposed()); assertTrue(errors.toString(), errors.isEmpty()); } | public static boolean validate(Disposable upstream, Disposable next, Class<?> observer) { ObjectHelper.requireNonNull(next, "next is null"); if (upstream != null) { next.dispose(); if (upstream != DisposableHelper.DISPOSED) { reportDoubleSubscription(observer); } return false; } return true; } | EndObserverHelper { public static boolean validate(Disposable upstream, Disposable next, Class<?> observer) { ObjectHelper.requireNonNull(next, "next is null"); if (upstream != null) { next.dispose(); if (upstream != DisposableHelper.DISPOSED) { reportDoubleSubscription(observer); } return false; } return true; } } | EndObserverHelper { public static boolean validate(Disposable upstream, Disposable next, Class<?> observer) { ObjectHelper.requireNonNull(next, "next is null"); if (upstream != null) { next.dispose(); if (upstream != DisposableHelper.DISPOSED) { reportDoubleSubscription(observer); } return false; } return true; } priva... | EndObserverHelper { public static boolean validate(Disposable upstream, Disposable next, Class<?> observer) { ObjectHelper.requireNonNull(next, "next is null"); if (upstream != null) { next.dispose(); if (upstream != DisposableHelper.DISPOSED) { reportDoubleSubscription(observer); } return false; } return true; } priva... | EndObserverHelper { public static boolean validate(Disposable upstream, Disposable next, Class<?> observer) { ObjectHelper.requireNonNull(next, "next is null"); if (upstream != null) { next.dispose(); if (upstream != DisposableHelper.DISPOSED) { reportDoubleSubscription(observer); } return false; } return true; } priva... |
@Test public void fromArray() { String[] items = new String[] { "one", "two", "three" }; assertEquals((Long)3L, Observable.fromArray(items).count().blockingGet()); assertEquals("two", Observable.fromArray(items).skip(1).take(1).blockingSingle()); assertEquals("three", Observable.fromArray(items).takeLast(1).blockingSin... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromArray(T... items) { ObjectHelper.requireNonNull(items, "items is null"); if (items.length == 0) { return empty(); } else if (items.length == 1) { return just(items[0]); } return RxJavaObservablePlugins.onAssembly(new Observab... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromArray(T... items) { ObjectHelper.requireNonNull(items, "items is null"); if (items.length == 0) { return empty(); } else if (items.length == 1) { return just(items[0]); } return RxJ... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromArray(T... items) { ObjectHelper.requireNonNull(items, "items is null"); if (items.length == 0) { return empty(); } else if (items.length == 1) { return just(items[0]); } return RxJ... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromArray(T... items) { ObjectHelper.requireNonNull(items, "items is null"); if (items.length == 0) { return empty(); } else if (items.length == 1) { return just(items[0]); } return RxJ... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromArray(T... items) { ObjectHelper.requireNonNull(items, "items is null"); if (items.length == 0) { return empty(); } else if (items.length == 1) { return just(items[0]); } return RxJ... |
@Test public void fromIterable() { ArrayList<String> items = new ArrayList<String>(); items.add("one"); items.add("two"); items.add("three"); assertEquals((Long)3L, Observable.fromIterable(items).count().blockingGet()); assertEquals("two", Observable.fromIterable(items).skip(1).take(1).blockingSingle()); assertEquals("... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromIterable(Iterable<? extends T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableFromIterable<T>(source)); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromIterable(Iterable<? extends T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableFromIterable<T>(source)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromIterable(Iterable<? extends T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableFromIterable<T>(source)); } ... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromIterable(Iterable<? extends T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableFromIterable<T>(source)); } ... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> fromIterable(Iterable<? extends T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableFromIterable<T>(source)); } ... |
@Test public void testCreate() { Observable<String> o = Observable.just("one", "two", "three"); Observer<String> observer = TestHelper.mockObserver(); o.subscribe(observer); verify(observer, times(1)).onNext("one"); verify(observer, times(1)).onNext("two"); verify(observer, times(1)).onNext("three"); verify(observer, n... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> create(ObservableOnSubscribe<T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableCreate<T>(source)); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> create(ObservableOnSubscribe<T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableCreate<T>(source)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> create(ObservableOnSubscribe<T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableCreate<T>(source)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> create(ObservableOnSubscribe<T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableCreate<T>(source)); } @CheckRet... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> create(ObservableOnSubscribe<T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaObservablePlugins.onAssembly(new ObservableCreate<T>(source)); } @CheckRet... |
@Test public void testReduce() { Observable<Integer> o = Observable.just(1, 2, 3, 4); o.reduce(new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { return t1 + t2; } }) .subscribe(wm); verify(wm, times(1)).onSuccess(anyInt()); verify(wm).onSuccess(10); verify(wm, never(... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> reduce(BiFunction<T, T, T> reducer) { ObjectHelper.requireNonNull(reducer, "reducer is null"); return RxJavaObservablePlugins.onAssembly(new ObservableReduceMaybe<T>(this, reducer)); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> reduce(BiFunction<T, T, T> reducer) { ObjectHelper.requireNonNull(reducer, "reducer is null"); return RxJavaObservablePlugins.onAssembly(new ObservableReduceMaybe<T>(this, reducer)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> reduce(BiFunction<T, T, T> reducer) { ObjectHelper.requireNonNull(reducer, "reducer is null"); return RxJavaObservablePlugins.onAssembly(new ObservableReduceMaybe<T>(this, reducer)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> reduce(BiFunction<T, T, T> reducer) { ObjectHelper.requireNonNull(reducer, "reducer is null"); return RxJavaObservablePlugins.onAssembly(new ObservableReduceMaybe<T>(this, reducer)); } @CheckRet... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> reduce(BiFunction<T, T, T> reducer) { ObjectHelper.requireNonNull(reducer, "reducer is null"); return RxJavaObservablePlugins.onAssembly(new ObservableReduceMaybe<T>(this, reducer)); } @CheckRet... |
@Test public void scheduleDirect() { final int[] count = { 0 }; ImmediateThinScheduler.INSTANCE.scheduleDirect(new Runnable() { @Override public void run() { count[0]++; } }); assertEquals(1, count[0]); } | @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } private ImmediateThinScheduler(); } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run... | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run... |
@Test public void testReplay() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); ConnectableObservable<String> o = Observable.<String>unsafeCreate(new ObservableSource<String>() { @Override public void subscribe(final Observer<? super String> observer) { observer.onSubscribe(Disposables.e... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final ConnectableObservable<T> replay() { return ObservableReplay.createFrom(this); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final ConnectableObservable<T> replay() { return ObservableReplay.createFrom(this); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final ConnectableObservable<T> replay() { return ObservableReplay.createFrom(this); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final ConnectableObservable<T> replay() { return ObservableReplay.createFrom(this); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observable<T> amb(Iterable<? extends ObservableSource<? e... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final ConnectableObservable<T> replay() { return ObservableReplay.createFrom(this); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observable<T> amb(Iterable<? extends ObservableSource<? e... |
@Test public void testCache() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); Observable<String> o = Observable.<String>unsafeCreate(new ObservableSource<String>() { @Override public void subscribe(final Observer<? super String> observer) { observer.onSubscribe(Disposables.empty()); new... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> cache() { return ObservableCache.from(this); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> cache() { return ObservableCache.from(this); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> cache() { return ObservableCache.from(this); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> cache() { return ObservableCache.from(this); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observable<T> amb(Iterable<? extends ObservableSource<? extends T>> sources)... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> cache() { return ObservableCache.from(this); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observable<T> amb(Iterable<? extends ObservableSource<? extends T>> sources)... |
@Test public void testOfType() { Observable<String> o = Observable.just(1, "abc", false, 2L).ofType(String.class); Observer<Object> observer = TestHelper.mockObserver(); o.subscribe(observer); verify(observer, never()).onNext(1); verify(observer, times(1)).onNext("abc"); verify(observer, never()).onNext(false); verify(... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Observable<U> ofType(final Class<U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return filter(Functions.isInstanceOf(clazz)).cast(clazz); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Observable<U> ofType(final Class<U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return filter(Functions.isInstanceOf(clazz)).cast(clazz); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Observable<U> ofType(final Class<U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return filter(Functions.isInstanceOf(clazz)).cast(clazz); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Observable<U> ofType(final Class<U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return filter(Functions.isInstanceOf(clazz)).cast(clazz); } @CheckReturnValue @SchedulerSupport(Sched... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Observable<U> ofType(final Class<U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return filter(Functions.isInstanceOf(clazz)).cast(clazz); } @CheckReturnValue @SchedulerSupport(Sched... |
@Test public void testContains() { Single<Boolean> o = Observable.just("a", "b", "c").contains("b"); SingleObserver<Boolean> observer = TestHelper.mockSingleObserver(); o.subscribe(observer); verify(observer, times(1)).onSuccess(true); verify(observer, never()).onSuccess(false); verify(observer, never()).onError( any(T... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Single<Boolean> contains(final Object element) { ObjectHelper.requireNonNull(element, "element is null"); return any(Functions.equalsWith(element)); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Single<Boolean> contains(final Object element) { ObjectHelper.requireNonNull(element, "element is null"); return any(Functions.equalsWith(element)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Single<Boolean> contains(final Object element) { ObjectHelper.requireNonNull(element, "element is null"); return any(Functions.equalsWith(element)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Single<Boolean> contains(final Object element) { ObjectHelper.requireNonNull(element, "element is null"); return any(Functions.equalsWith(element)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Single<Boolean> contains(final Object element) { ObjectHelper.requireNonNull(element, "element is null"); return any(Functions.equalsWith(element)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport... |
@Test public void testIgnoreElements() { Completable o = Observable.just(1, 2, 3).ignoreElements(); CompletableObserver observer = TestHelper.mockCompletableObserver(); o.subscribe(observer); verify(observer, never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable ignoreElements() { return RxJavaObservablePlugins.onAssembly(new ObservableIgnoreElementsCompletable<T>(this)); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable ignoreElements() { return RxJavaObservablePlugins.onAssembly(new ObservableIgnoreElementsCompletable<T>(this)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable ignoreElements() { return RxJavaObservablePlugins.onAssembly(new ObservableIgnoreElementsCompletable<T>(this)); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable ignoreElements() { return RxJavaObservablePlugins.onAssembly(new ObservableIgnoreElementsCompletable<T>(this)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observable<... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable ignoreElements() { return RxJavaObservablePlugins.onAssembly(new ObservableIgnoreElementsCompletable<T>(this)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observable<... |
@Test public void testMergeWith() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable.just(1).mergeWith(Observable.just(2)).subscribe(ts); ts.assertValues(1, 2); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return merge(this, other); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return merge(this, other); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return merge(this, other); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return merge(this, other); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE)... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return merge(this, other); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE)... |
@Test public void testConcatWith() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable.just(1).concatWith(Observable.just(2)).subscribe(ts); ts.assertValues(1, 2); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> concatWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return concat(this, other); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> concatWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return concat(this, other); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> concatWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return concat(this, other); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> concatWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return concat(this, other); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NON... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> concatWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return concat(this, other); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NON... |
@Test public void testAmbWith() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable.just(1).ambWith(Observable.just(2)).subscribe(ts); ts.assertValue(1); } | @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> ambWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return ambArray(this, other); } | Observable implements ObservableSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> ambWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return ambArray(this, other); } } | Observable implements ObservableSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> ambWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return ambArray(this, other); } } | Observable implements ObservableSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> ambWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return ambArray(this, other); } @CheckReturnValue @Schedul... | Observable implements ObservableSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> ambWith(ObservableSource<? extends T> other) { ObjectHelper.requireNonNull(other, "other is null"); return ambArray(this, other); } @CheckReturnValue @Schedul... |
@Test public void testCompose() { TestObserver<String> ts = new TestObserver<String>(); Observable.just(1, 2, 3).compose(new ObservableTransformer<Integer, String>() { @Override public Observable<String> apply(Observable<Integer> t1) { return t1.map(new Function<Integer, String>() { @Override public String apply(Intege... | @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) { return wrap(((ObservableTransformer<T, R>) ObjectHelper.requireNonNull(composer, "composer is null")).apply(this)); } | Observable implements ObservableSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) { return wrap(((ObservableTransformer<T, R>) ObjectHelper.requireNonNull(composer, "compose... | Observable implements ObservableSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) { return wrap(((ObservableTransformer<T, R>) ObjectHelper.requireNonNull(composer, "compose... | Observable implements ObservableSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) { return wrap(((ObservableTransformer<T, R>) ObjectHelper.requireNonNull(composer, "compose... | Observable implements ObservableSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) { return wrap(((ObservableTransformer<T, R>) ObjectHelper.requireNonNull(composer, "compose... |
@Test public void testEmptyIdentity() { assertEquals(Observable.empty(), Observable.empty()); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> empty() { return RxJavaObservablePlugins.onAssembly((Observable<T>) ObservableEmpty.INSTANCE); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> empty() { return RxJavaObservablePlugins.onAssembly((Observable<T>) ObservableEmpty.INSTANCE); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> empty() { return RxJavaObservablePlugins.onAssembly((Observable<T>) ObservableEmpty.INSTANCE); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> empty() { return RxJavaObservablePlugins.onAssembly((Observable<T>) ObservableEmpty.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NON... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> empty() { return RxJavaObservablePlugins.onAssembly((Observable<T>) ObservableEmpty.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NON... |
@Test(expected = UnsupportedOperationException.class) public void scheduleDirectTimed() { ImmediateThinScheduler.INSTANCE.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.SECONDS); } | @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } private ImmediateThinScheduler(); } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run... | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run) { run.run(); return DISPOSED; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run... |
@Test public void testFlatMap() { List<Integer> list = Observable.range(1, 5).flatMap(new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer v) { return Observable.range(v, 2); } }).toList().blockingGet(); Assert.assertEquals(Arrays.asList(1, 2, 2, 3, 3, 4, 4, 5, 5, 6), list);... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) { return flatMap(mapper, false); } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) { return flatMap(mapper, false); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) { return flatMap(mapper, false); } } | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) { return flatMap(mapper, false); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observa... | Observable implements ObservableSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) { return flatMap(mapper, false); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observa... |
@SuppressWarnings({ "rawtypes" }) @Test public void lockdown() throws Exception { RxJavaObservablePlugins.reset(); RxJavaObservablePlugins.lockdown(); try { assertTrue(RxJavaObservablePlugins.isLockdown()); Consumer a1 = Functions.emptyConsumer(); Callable f0 = new Callable() { @Override public Object call() { return n... | public static void lockdown() { lockdown = true; } | RxJavaObservablePlugins { public static void lockdown() { lockdown = true; } } | RxJavaObservablePlugins { public static void lockdown() { lockdown = true; } private RxJavaObservablePlugins(); } | RxJavaObservablePlugins { public static void lockdown() { lockdown = true; } private RxJavaObservablePlugins(); static void lockdown(); static boolean isLockdown(); static void reset(); @Nullable static Function<? super Completable, ? extends Completable> getOnCompletableAssembly(); @Nullable static BiFunction<? super... | RxJavaObservablePlugins { public static void lockdown() { lockdown = true; } private RxJavaObservablePlugins(); static void lockdown(); static boolean isLockdown(); static void reset(); @Nullable static Function<? super Completable, ? extends Completable> getOnCompletableAssembly(); @Nullable static BiFunction<? super... |
@Test public void testMap() { TestObserver<String> ts = new TestObserver<String>(); Single.just("A") .map(new Function<String, String>() { @Override public String apply(String s) { return s + "B"; } }) .toObservable().subscribe(ts); ts.assertValueSequence(Arrays.asList("AB")); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleMap<T, R>(this, mapper)); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleMap<T, R>(this, mapper)); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleMap<T, R>(this, mapper)); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleMap<T, R>(this, mapper)); } @CheckReturnVal... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleMap<T, R>(this, mapper)); } @CheckReturnVal... |
@Test public void testZip() { TestObserver<String> ts = new TestObserver<String>(); Single<String> a = Single.just("A"); Single<String> b = Single.just("B"); Single.zip(a, b, new BiFunction<String, String, String>() { @Override public String apply(String a1, String b1) { return a1 + b1; } }) .toObservable().subscribe(t... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Single<R> zip(final Iterable<? extends SingleSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper) { ObjectHelper.requireNonNull(zipper, "zipper is null"); ObjectHelper.requireNonNull(sources, "sources is null"); ret... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Single<R> zip(final Iterable<? extends SingleSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper) { ObjectHelper.requireNonNull(zipper, "zipper is null"); ObjectHelper.requireNonN... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Single<R> zip(final Iterable<? extends SingleSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper) { ObjectHelper.requireNonNull(zipper, "zipper is null"); ObjectHelper.requireNonN... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Single<R> zip(final Iterable<? extends SingleSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper) { ObjectHelper.requireNonNull(zipper, "zipper is null"); ObjectHelper.requireNonN... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Single<R> zip(final Iterable<? extends SingleSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper) { ObjectHelper.requireNonNull(zipper, "zipper is null"); ObjectHelper.requireNonN... |
@Test public void testZipWith() { TestObserver<String> ts = new TestObserver<String>(); Single.just("A").zipWith(Single.just("B"), new BiFunction<String, String, String>() { @Override public String apply(String a1, String b1) { return a1 + b1; } }) .toObservable().subscribe(ts); ts.assertValueSequence(Arrays.asList("AB... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Single<R> zipWith(SingleSource<U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { return zip(this, other, zipper); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Single<R> zipWith(SingleSource<U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { return zip(this, other, zipper); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Single<R> zipWith(SingleSource<U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { return zip(this, other, zipper); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Single<R> zipWith(SingleSource<U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { return zip(this, other, zipper); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Single<R> zipWith(SingleSource<U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { return zip(this, other, zipper); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single... |
@Test public void testMerge() { TestObserver<String> ts = new TestObserver<String>(); Single<String> a = Single.just("A"); Single<String> b = Single.just("B"); Single.merge(a, b).subscribe(ts); ts.assertValueSequence(Arrays.asList("A", "B")); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> merge(Iterable<? extends SingleSource<? extends T>> sources) { return merge(Observable.fromIterable(sources)); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> merge(Iterable<? extends SingleSource<? extends T>> sources) { return merge(Observable.fromIterable(sources)); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> merge(Iterable<? extends SingleSource<? extends T>> sources) { return merge(Observable.fromIterable(sources)); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> merge(Iterable<? extends SingleSource<? extends T>> sources) { return merge(Observable.fromIterable(sources)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> merge(Iterable<? extends SingleSource<? extends T>> sources) { return merge(Observable.fromIterable(sources)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb... |
@Test public void testMergeWith() { TestObserver<String> ts = new TestObserver<String>(); Single.just("A").mergeWith(Single.just("B")).subscribe(ts); ts.assertValueSequence(Arrays.asList("A", "B")); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(SingleSource<? extends T> other) { return merge(this, other); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(SingleSource<? extends T> other) { return merge(this, other); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(SingleSource<? extends T> other) { return merge(this, other); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(SingleSource<? extends T> other) { return merge(this, other); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Iterable<? extends SingleSource<? ext... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> mergeWith(SingleSource<? extends T> other) { return merge(this, other); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Iterable<? extends SingleSource<? ext... |
@Test public void testFlatMap() { TestObserver<String> ts = new TestObserver<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()); } } ).toObservable().subscribe(ts); if ... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> flatMap(Function<? super T, ? extends SingleSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleFlatMap<T, R>(this, mapper)); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> flatMap(Function<? super T, ? extends SingleSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleFlatMap<T, R>(th... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> flatMap(Function<? super T, ? extends SingleSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleFlatMap<T, R>(th... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> flatMap(Function<? super T, ? extends SingleSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleFlatMap<T, R>(th... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Single<R> flatMap(Function<? super T, ? extends SingleSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new SingleFlatMap<T, R>(th... |
@Test public void testTimeout() { TestObserver<String> ts = new TestObserver<String>(); Single<String> s1 = Single.<String>unsafeCreate(new SingleSource<String>() { @Override public void subscribe(SingleObserver<? super String> s) { s.onSubscribe(Disposables.empty()); try { Thread.sleep(5000); } catch (InterruptedExcep... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Single<T> timeout(long timeout, TimeUnit unit) { return timeout0(timeout, unit, Schedulers.computation(), null); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Single<T> timeout(long timeout, TimeUnit unit) { return timeout0(timeout, unit, Schedulers.computation(), null); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Single<T> timeout(long timeout, TimeUnit unit) { return timeout0(timeout, unit, Schedulers.computation(), null); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Single<T> timeout(long timeout, TimeUnit unit) { return timeout0(timeout, unit, Schedulers.computation(), null); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Ite... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Single<T> timeout(long timeout, TimeUnit unit) { return timeout0(timeout, unit, Schedulers.computation(), null); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Ite... |
@Test public void toObservable() { Observable<String> a = Single.just("a").toObservable(); TestObserver<String> ts = new TestObserver<String>(); a.subscribe(ts); ts.assertValue("a"); ts.assertNoErrors(); ts.assertComplete(); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public final Observable<T> toObservable() { if (this instanceof FuseToObservable) { return ((FuseToObservable<T>)this).fuseToObservable(); } return RxJavaObservablePlugins.onAssembly(new SingleToObservable<T>(this)); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public final Observable<T> toObservable() { if (this instanceof FuseToObservable) { return ((FuseToObservable<T>)this).fuseToObservable(); } return RxJavaObservablePlugins.onAssembly(new SingleT... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public final Observable<T> toObservable() { if (this instanceof FuseToObservable) { return ((FuseToObservable<T>)this).fuseToObservable(); } return RxJavaObservablePlugins.onAssembly(new SingleT... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public final Observable<T> toObservable() { if (this instanceof FuseToObservable) { return ((FuseToObservable<T>)this).fuseToObservable(); } return RxJavaObservablePlugins.onAssembly(new SingleT... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public final Observable<T> toObservable() { if (this instanceof FuseToObservable) { return ((FuseToObservable<T>)this).fuseToObservable(); } return RxJavaObservablePlugins.onAssembly(new SingleT... |
@Test(expected = UnsupportedOperationException.class) public void scheduleDirectPeriodic() { ImmediateThinScheduler.INSTANCE.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.SECONDS); } | @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { throw new UnsupportedOperationException("This scheduler doesn't support periodic execution"); } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { throw new UnsupportedOperationException("This scheduler doesn't support periodic execution"); } } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { throw new UnsupportedOperationException("This scheduler doesn't support periodic execution"); } private ImmediateThinScheduler(); } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { throw new UnsupportedOperationException("This scheduler doesn't support periodic execution"); } private ImmediateThinScheduler(); @NonNull @... | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { throw new UnsupportedOperationException("This scheduler doesn't support periodic execution"); } private ImmediateThinScheduler(); @NonNull @... |
@Test public void toFuture() throws Exception { assertEquals(1, Single.just(1).toFuture().get().intValue()); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Future<T> toFuture() { return subscribeWith(new FutureSingleObserver<T>()); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Future<T> toFuture() { return subscribeWith(new FutureSingleObserver<T>()); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Future<T> toFuture() { return subscribeWith(new FutureSingleObserver<T>()); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Future<T> toFuture() { return subscribeWith(new FutureSingleObserver<T>()); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Iterable<? extends SingleSource<? extends T>> s... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Future<T> toFuture() { return subscribeWith(new FutureSingleObserver<T>()); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Iterable<? extends SingleSource<? extends T>> s... |
@Test(expected = UnsupportedOperationException.class) public void toObservableIterableRemove() { @SuppressWarnings("unchecked") Iterable<? extends Observable<Integer>> f = SingleInternalHelper.iterableToObservable(Arrays.asList(Single.just(1))); Iterator<? extends Observable<Integer>> iterator = f.iterator(); iterator.... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> just(final T item) { ObjectHelper.requireNonNull(item, "value is null"); return RxJavaObservablePlugins.onAssembly(new SingleJust<T>(item)); } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> just(final T item) { ObjectHelper.requireNonNull(item, "value is null"); return RxJavaObservablePlugins.onAssembly(new SingleJust<T>(item)); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> just(final T item) { ObjectHelper.requireNonNull(item, "value is null"); return RxJavaObservablePlugins.onAssembly(new SingleJust<T>(item)); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> just(final T item) { ObjectHelper.requireNonNull(item, "value is null"); return RxJavaObservablePlugins.onAssembly(new SingleJust<T>(item)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> just(final T item) { ObjectHelper.requireNonNull(item, "value is null"); return RxJavaObservablePlugins.onAssembly(new SingleJust<T>(item)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.... |
@Test public void to() { assertEquals(1, Single.just(1).to(new Function<Single<Integer>, Integer>() { @Override public Integer apply(Single<Integer> v) throws Exception { return 1; } }).intValue()); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Single<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOrThrow(ex); } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Single<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wra... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Single<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wra... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Single<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wra... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Single<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wra... |
@Test(expected = NullPointerException.class) public void fromObservableNull() { Single.fromObservable(null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> fromObservable(ObservableSource<? extends T> observableSource) { ObjectHelper.requireNonNull(observableSource, "observableSource is null"); return RxJavaObservablePlugins.onAssembly(new ObservableSingleSingle<T>(observableSource, nul... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> fromObservable(ObservableSource<? extends T> observableSource) { ObjectHelper.requireNonNull(observableSource, "observableSource is null"); return RxJavaObservablePlugins.onAssembly(new ObservableS... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> fromObservable(ObservableSource<? extends T> observableSource) { ObjectHelper.requireNonNull(observableSource, "observableSource is null"); return RxJavaObservablePlugins.onAssembly(new ObservableS... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> fromObservable(ObservableSource<? extends T> observableSource) { ObjectHelper.requireNonNull(observableSource, "observableSource is null"); return RxJavaObservablePlugins.onAssembly(new ObservableS... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<T> fromObservable(ObservableSource<? extends T> observableSource) { ObjectHelper.requireNonNull(observableSource, "observableSource is null"); return RxJavaObservablePlugins.onAssembly(new ObservableS... |
@Test(expected = NullPointerException.class) public void implementationThrows() { new Single<Integer>() { @Override protected void subscribeActual(SingleObserver<? super Integer> observer) { throw new NullPointerException(); } }.test(); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } } | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Iterable<? extends SingleSou... | Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Iterable<? extends SingleSou... |
@Test(expected = NullPointerException.class) public void nullResource() { TestResourceSubscriber<Integer> ro = new TestResourceSubscriber<Integer>(); ro.add(null); } | public final void add(Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { public final void add(Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { public final void add(Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { public final void add(Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Ove... | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { public final void add(Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Ove... |
@Test public void normal() { TestResourceSubscriber<Integer> tc = new TestResourceSubscriber<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); Flowable.just(1).subscribe(tc); assertTrue(tc.isDisposed()); assertEquals(1, tc.start); asse... | @Override public final boolean isDisposed() { return SubscriptionHelper.isCancelled(s.get()); } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return SubscriptionHelper.isCancelled(s.get()); } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return SubscriptionHelper.isCancelled(s.get()); } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return SubscriptionHelper.isCancelled(s.get()); } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed(); } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return SubscriptionHelper.isCancelled(s.get()); } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed(); ... |
@Test public void startOnce() { List<Throwable> error = TestCommonHelper.trackPluginErrors(); try { TestResourceSubscriber<Integer> tc = new TestResourceSubscriber<Integer>(); tc.onSubscribe(new BooleanSubscription()); BooleanSubscription d = new BooleanSubscription(); tc.onSubscribe(d); assertTrue(d.isCancelled()); as... | @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { long r = missedRequested.getAndSet(0L); if (r != 0L) { s.request(r); } onStart(); } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { long r = missedRequested.getAndSet(0L); if (r != 0L) { s.request(r); } onStart(); } } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { long r = missedRequested.getAndSet(0L); if (r != 0L) { s.request(r); } onStart(); } } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { long r = missedRequested.getAndSet(0L); if (r != 0L) { s.request(r); } onStart(); } } final void add(Disposable resource); @Override final... | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { long r = missedRequested.getAndSet(0L); if (r != 0L) { s.request(r); } onStart(); } } final void add(Disposable resource); @Override final... |
@Test public void dispose() { TestResourceSubscriber<Integer> tc = new TestResourceSubscriber<Integer>(); tc.dispose(); BooleanSubscription d = new BooleanSubscription(); tc.onSubscribe(d); assertTrue(d.isCancelled()); assertEquals(0, tc.start); } | @Override public final void dispose() { if (SubscriptionHelper.cancel(s)) { resources.dispose(); } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { if (SubscriptionHelper.cancel(s)) { resources.dispose(); } } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { if (SubscriptionHelper.cancel(s)) { resources.dispose(); } } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { if (SubscriptionHelper.cancel(s)) { resources.dispose(); } } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed... | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { if (SubscriptionHelper.cancel(s)) { resources.dispose(); } } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed... |
@Test public void request() { TestResourceSubscriber<Integer> tc = new TestResourceSubscriber<Integer>() { @Override protected void onStart() { start++; } }; Flowable.just(1).subscribe(tc); assertEquals(1, tc.start); assertEquals(Collections.emptyList(), tc.values); assertTrue(tc.errors.isEmpty()); assertEquals(0, tc.c... | protected final void request(long n) { SubscriptionHelper.deferredRequest(s, missedRequested, n); } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { protected final void request(long n) { SubscriptionHelper.deferredRequest(s, missedRequested, n); } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { protected final void request(long n) { SubscriptionHelper.deferredRequest(s, missedRequested, n); } } | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { protected final void request(long n) { SubscriptionHelper.deferredRequest(s, missedRequested, n); } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed(... | ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { protected final void request(long n) { SubscriptionHelper.deferredRequest(s, missedRequested, n); } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed(... |
@Test public void schedule() { final int[] count = { 0 }; Worker w = ImmediateThinScheduler.INSTANCE.createWorker(); assertFalse(w.isDisposed()); w.schedule(new Runnable() { @Override public void run() { count[0]++; } }); assertEquals(1, count[0]); } | @NonNull @Override public Worker createWorker() { return WORKER; } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @... | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @... |
@Test public void normal() { TestDisposableSubscriber<Integer> tc = new TestDisposableSubscriber<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); Flowable.just(1).subscribe(tc); assertFalse(tc.isDisposed()); assertEquals(1, tc.start);... | @Override public final boolean isDisposed() { return s.get() == SubscriptionHelper.CANCELLED; } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == SubscriptionHelper.CANCELLED; } } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == SubscriptionHelper.CANCELLED; } } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == SubscriptionHelper.CANCELLED; } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == SubscriptionHelper.CANCELLED; } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); } |
@Test public void startOnce() { List<Throwable> error = TestCommonHelper.trackPluginErrors(); try { TestDisposableSubscriber<Integer> tc = new TestDisposableSubscriber<Integer>(); tc.onSubscribe(new BooleanSubscription()); BooleanSubscription d = new BooleanSubscription(); tc.onSubscribe(d); assertTrue(d.isCancelled())... | @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { onStart(); } } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { onStart(); } } } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { onStart(); } } } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { onStart(); } } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { onStart(); } } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); ... |
@Test public void dispose() { TestDisposableSubscriber<Integer> tc = new TestDisposableSubscriber<Integer>(); assertFalse(tc.isDisposed()); tc.dispose(); assertTrue(tc.isDisposed()); BooleanSubscription d = new BooleanSubscription(); tc.onSubscribe(d); assertTrue(d.isCancelled()); assertEquals(0, tc.start); } | @Override public final void dispose() { SubscriptionHelper.cancel(s); } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { SubscriptionHelper.cancel(s); } } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { SubscriptionHelper.cancel(s); } } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { SubscriptionHelper.cancel(s); } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); } | DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { SubscriptionHelper.cancel(s); } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); } |
@Test public void onNextFailure() { AtomicReference<Throwable> onError = new AtomicReference<Throwable>(); try { OBSERVER_ONNEXT_FAIL(onError).onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { assertNull(onError.get()); assertTrue(e instanceof SafeSubscriberTestException); assertEquals("onN... | @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."); try { s.cancel(); } catch (Throwable e1) { Exceptions.thr... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... |
@Test public void onCompleteFailure() { AtomicReference<Throwable> onError = new AtomicReference<Throwable>(); try { OBSERVER_ONCOMPLETED_FAIL(onError).onComplete(); fail("expects exception to be thrown"); } catch (Exception e) { assertNull(onError.get()); assertTrue(e instanceof SafeSubscriberTestException); assertEqu... | @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... |
@Test public void onErrorFailure() { try { OBSERVER_ONERROR_FAIL().onError(new SafeSubscriberTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { assertTrue(e instanceof SafeSubscriberTestException); assertEquals("onErrorFail", e.getMessage()); } } | @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugin... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... |
@Test @Ignore("Observers can't throw") public void onErrorFailureSafe() { try { new SafeSubscriber<String>(OBSERVER_ONERROR_FAIL()).onError(new SafeSubscriberTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof RuntimeException); assertEq... | @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugin... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... |
@Test @Ignore("Observers can't throw") public void onErrorNotImplementedFailureSafe() { try { new SafeSubscriber<String>(OBSERVER_ONERROR_NOTIMPLEMENTED()).onError(new SafeSubscriberTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { assertTrue(e.getCause() instanceof SafeSubscribe... | @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugin... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... |
@Test public void onNextOnErrorFailure() { try { OBSERVER_ONNEXT_ONERROR_FAIL().onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof SafeSubscriberTestException); assertEquals("onNextFail", e.getMessage()); } } | @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."); try { s.cancel(); } catch (Throwable e1) { Exceptions.thr... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... |
@Test @Ignore("Observers can't throw") public void onNextOnErrorFailureSafe() { try { new SafeSubscriber<String>(OBSERVER_ONNEXT_ONERROR_FAIL()).onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof RuntimeException); assertEquals("Error occurred whe... | @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."); try { s.cancel(); } catch (Throwable e1) { Exceptions.thr... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... |
@Test(expected = UnsupportedOperationException.class) public void scheduleTimed() { ImmediateThinScheduler.INSTANCE.createWorker().schedule(Functions.EMPTY_RUNNABLE, 1, TimeUnit.SECONDS); } | @NonNull @Override public Worker createWorker() { return WORKER; } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @... | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @... |
@Test @Ignore("Observers can't throw") public void testOnCompletedThrows() { final AtomicReference<Throwable> error = new AtomicReference<Throwable>(); SafeSubscriber<Integer> s = new SafeSubscriber<Integer>(new DefaultSubscriber<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Thr... | @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... |
@Test public void dispose() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SafeSubscriber<Integer> so = new SafeSubscriber<Integer>(ts); BooleanSubscription d = new BooleanSubscription(); so.onSubscribe(d); ts.dispose(); assertTrue(d.isCancelled()); } | @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); RxJavaCommonPlugins.onError(new Composite... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... |
@Test public void onNextWithoutOnSubscribe() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SafeSubscriber<Integer> so = new SafeSubscriber<Integer>(ts); so.onNext(1); ts.assertFailureAndMessage(NullPointerException.class, "Subscription not set!"); } | @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."); try { s.cancel(); } catch (Throwable e1) { Exceptions.thr... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... |
@Test public void onErrorWithoutOnSubscribe() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SafeSubscriber<Integer> so = new SafeSubscriber<Integer>(ts); so.onError(new TestException()); ts.assertFailure(CompositeException.class); TestHelper.assertError(ts, 0, TestException.class); TestHelper.assertErro... | @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugin... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... |
@Test public void onCompleteWithoutOnSubscribe() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SafeSubscriber<Integer> so = new SafeSubscriber<Integer>(ts); so.onComplete(); ts.assertFailureAndMessage(NullPointerException.class, "Subscription not set!"); } | @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... |
@Test public void onSubscribeTwice() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onSubscribe(cd); so.onSubscribe(cd); TestCommonHelper.assertError(list, 0, IllegalStateException.cla... | @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); RxJavaCommonPlugins.onError(new Composite... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... |
@Test public void onSubscribeCrashes() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onSubscribe(cd); TestCommonHelper.assertUndeliverable(list, 0, TestException.class, "onSubscribe()"... | @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); RxJavaCommonPlugins.onError(new Composite... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... |
@Test public void onSubscribeAndDisposeCrashes() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, true, false); SafeSubscriber<Object> so = cd.toSafe(); so.onSubscribe(cd); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Thr... | @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); RxJavaCommonPlugins.onError(new Composite... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Excepti... |
@Test public void onNextOnSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onNext(1); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce ... | @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."); try { s.cancel(); } catch (Throwable e1) { Exceptions.thr... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... |
@Test public void noSubscribeOnErrorCrashes() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onNext(1); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ... | @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."); try { s.cancel(); } catch (Throwable e1) { Exceptions.thr... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and source... |
@Test(expected = UnsupportedOperationException.class) public void schedulePeriodic() { ImmediateThinScheduler.INSTANCE.createWorker().schedulePeriodically(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.SECONDS); } | @NonNull @Override public Worker createWorker() { return WORKER; } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); } | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @... | ImmediateThinScheduler extends Scheduler { @NonNull @Override public Worker createWorker() { return WORKER; } private ImmediateThinScheduler(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @... |
@Test public void disposeSelfPeriodicDirect() { final int[] count = { 0 }; TestScheduler scheduler = new TestScheduler(); final SequentialDisposable sd = new SequentialDisposable(); Disposable d = scheduler.schedulePeriodicallyDirect(new Runnable() { @Override public void run() { count[0]++; sd.dispose(); } }, 100, 100... | @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w); Disposable... | Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w)... | Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w)... | Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w)... | Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w)... |
@Test public void onErrorNoSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onError(new TestException()); TestCommonHelper.assertError(list, 0, CompositeException.class);... | @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugin... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... |
@Test public void onErrorNoSubscribeOnErrorCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onError(new TestException()); TestCommonHelper.assertError(list, 0, CompositeException.... | @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugin... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch... |
@Test public void onCompleteteNoSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, true, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onComplete(); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwa... | @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... |
@Test public void onCompleteteNoSubscribeOnErrorCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, true, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onComplete(); TestCommonHelper.assertError(list, 0, CompositeException.class); List... | @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } } | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... | SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(... |
@Test public void testMultiThreadedBasic() { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three"); Flowable<String> w = Flowable.unsafeCreate(onSubscribe); BusySubscriber busySubscriber = new BusySubscriber(); Subscriber<String> aw = serializedSubscriber(busySubscriber); w.su... | public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s);... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s);... |
@Test(timeout = 1000) public void testMultiThreadedWithNPE() throws InterruptedException { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null); Flowable<String> w = Flowable.unsafeCreate(onSubscribe); BusySubscriber busySubscriber = new BusySubscriber(); Subscriber<Str... | public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s);... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s);... |
@Test public void testMultiThreadedWithNPEinMiddle() { int n = 10; for (int i = 0; i < n; i++) { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine"); Flowable<String> w = Flowable.unsafeCreate(onSubscribe); BusySubscribe... | public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s);... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s);... |
@Test public void runOutOfOrderConcurrencyTest() { ExecutorService tp = Executors.newFixedThreadPool(20); try { TestConcurrencySubscriber tw = new TestConcurrencySubscriber(); Subscriber<String> w = serializedSubscriber(new SafeSubscriber<String>(tw)); Future<?> f1 = tp.submit(new OnNextThread(w, 12000)); Future<?> f2 ... | public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s);... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s);... |
@Test @Ignore("Null values not permitted") public void testSerializeNull() { final AtomicReference<Subscriber<Integer>> serial = new AtomicReference<Subscriber<Integer>>(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { if (t != null && t == 0) { serial.get().onNe... | @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized (this) { if (done) { return; } if (emitting) { AppendOnlyLinkedArray... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized... |
@Test @Ignore("Null values no longer permitted") public void testSerializeDrainPhaseThrows() { final AtomicReference<Subscriber<Integer>> serial = new AtomicReference<Subscriber<Integer>>(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { if (t != null && t == 0) {... | @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized (this) { if (done) { return; } if (emitting) { AppendOnlyLinkedArray... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized... |
@Test public void disposeRace() { for (int i = 0; i < 100; i++) { final ArrayCompositeDisposable acd = new ArrayCompositeDisposable(2); Runnable r = new Runnable() { @Override public void run() { acd.dispose(); } }; TestCommonHelper.race(r, r, Schedulers.io()); } } | @Override public void dispose() { if (get(0) != DisposableHelper.DISPOSED) { int s = length(); for (int i = 0; i < s; i++) { Disposable o = get(i); if (o != DisposableHelper.DISPOSED) { o = getAndSet(i, DisposableHelper.DISPOSED); if (o != DisposableHelper.DISPOSED && o != null) { o.dispose(); } } } } } | ArrayCompositeDisposable extends AtomicReferenceArray<Disposable> implements Disposable { @Override public void dispose() { if (get(0) != DisposableHelper.DISPOSED) { int s = length(); for (int i = 0; i < s; i++) { Disposable o = get(i); if (o != DisposableHelper.DISPOSED) { o = getAndSet(i, DisposableHelper.DISPOSED);... | ArrayCompositeDisposable extends AtomicReferenceArray<Disposable> implements Disposable { @Override public void dispose() { if (get(0) != DisposableHelper.DISPOSED) { int s = length(); for (int i = 0; i < s; i++) { Disposable o = get(i); if (o != DisposableHelper.DISPOSED) { o = getAndSet(i, DisposableHelper.DISPOSED);... | ArrayCompositeDisposable extends AtomicReferenceArray<Disposable> implements Disposable { @Override public void dispose() { if (get(0) != DisposableHelper.DISPOSED) { int s = length(); for (int i = 0; i < s; i++) { Disposable o = get(i); if (o != DisposableHelper.DISPOSED) { o = getAndSet(i, DisposableHelper.DISPOSED);... | ArrayCompositeDisposable extends AtomicReferenceArray<Disposable> implements Disposable { @Override public void dispose() { if (get(0) != DisposableHelper.DISPOSED) { int s = length(); for (int i = 0; i < s; i++) { Disposable o = get(i); if (o != DisposableHelper.DISPOSED) { o = getAndSet(i, DisposableHelper.DISPOSED);... |
@Test public void startOnce() { List<Throwable> error = TestCommonHelper.trackPluginErrors(); try { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); final SerializedSubscriber<Integer> so = new SerializedSubscriber<Integer>(ts); so.onSubscribe(new BooleanSubscription()); BooleanSubscription d = new BooleanSu... | @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.subscription, s)) { this.subscription = s; actual.onSubscribe(this); } } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.subscription, s)) { this.subscription = s; actual.onSubscribe(this); } } } | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.subscription, s)) { this.subscription = s; actual.onSubscribe(this); } } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? su... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.subscription, s)) { this.subscription = s; actual.onSubscribe(this); } } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? su... | SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.subscription, s)) { this.subscription = s; actual.onSubscribe(this); } } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? su... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.