Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: ScheduledDirectPeriodicTask extends AbstractDirectTask implements Runnable { @Override public void run() { runner = Thread.currentThread(); try { try { runnable.run(); } catch (Throwable ex) { lazySet(FINISHED); RxJavaCommonPlugins.onError(ex); } } finally { runner = null; } } ScheduledDirectPeriodicTask(Runnable runnable); @Override void run(); }### Answer: @Test public void runnableThrows() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { ScheduledDirectPeriodicTask task = new ScheduledDirectPeriodicTask(new Runnable() { @Override public void run() { throw new TestException(); } }); task.run(); TestCommonHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaCommonPlugins.reset(); } }
### Question: ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <U, R> Observable<R> multicastSelector( final Callable<? extends ConnectableObservable<U>> connectableFactory, final Function<? super Observable<U>, ? extends ObservableSource<R>> selector) { return RxJavaObservablePlugins.onAssembly(new MulticastReplay<R, U>(connectableFactory, selector)); } private ObservableReplay(ObservableSource<T> onSubscribe, ObservableSource<T> source, final AtomicReference<ReplayObserver<T>> current, final BufferSupplier<T> bufferFactory); static Observable<R> multicastSelector( final Callable<? extends ConnectableObservable<U>> connectableFactory, final Function<? super Observable<U>, ? extends ObservableSource<R>> selector); static ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler); @SuppressWarnings("unchecked") static ConnectableObservable<T> createFrom(ObservableSource<? extends T> source); static ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize); static ConnectableObservable<T> create(ObservableSource<T> source, long maxAge, TimeUnit unit, Scheduler scheduler); static ConnectableObservable<T> create(ObservableSource<T> source, final long maxAge, final TimeUnit unit, final Scheduler scheduler, final int bufferSize); @Override ObservableSource<T> source(); @Override void dispose(); @Override boolean isDisposed(); @Override void connect(Consumer<? super Disposable> connection); }### Answer: @Test public void replaySelectorConnectableReturnsNull() { ObservableReplay.multicastSelector(Functions.justCallable((ConnectableObservable<Integer>)null), Functions.justFunction(Observable.just(1))) .test() .assertFailureAndMessage(NullPointerException.class, "The connectableFactory returned a null ConnectableObservable"); }
### Question: MaybeFromSingle extends Maybe<T> implements HasUpstreamSingleSource<T> { @Override public SingleSource<T> source() { return source; } MaybeFromSingle(SingleSource<T> source); @Override SingleSource<T> source(); }### Answer: @Test public void source() { Single<Integer> c = Single.never(); assertSame(c, ((HasUpstreamSingleSource<?>)Maybe.fromSingle(c)).source()); }
### Question: MaybeContains extends Single<Boolean> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeContains(MaybeSource<T> source, Object value); @Override MaybeSource<T> source(); }### Answer: @SuppressWarnings("unchecked") @Test public void hasSource() { assertSame(Maybe.empty(), ((HasUpstreamMaybeSource<Object>)(Maybe.empty().contains(0))).source()); }
### Question: ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE \|\| o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THREAD_INDEX) != Thread.currentThread()); } break; } } for (;;) { Object o = get(PARENT_INDEX); if (o == DONE \|\| o == DISPOSED \|\| o == null) { return; } if (compareAndSet(PARENT_INDEX, o, DISPOSED)) { ((DisposableContainer)o).delete(this); return; } } } ScheduledRunnable(Runnable actual, DisposableContainer parent); @Override Object call(); @Override void run(); void setFuture(Future<?> f); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void dispose() { CompositeDisposable set = new CompositeDisposable(); ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set); set.add(run); assertFalse(run.isDisposed()); set.dispose(); assertTrue(run.isDisposed()); } @Test public void disposeRace() { for (int i = 0; i < 500; i++) { CompositeDisposable set = new CompositeDisposable(); final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set); set.add(run); Runnable r1 = new Runnable() { @Override public void run() { run.dispose(); } }; TestCommonHelper.race(r1, r1); assertEquals(0, set.size()); } }
### Question: AbstractMaybeWithUpstream extends Maybe<R> implements HasUpstreamMaybeSource<T> { @Override public final MaybeSource<T> source() { return source; } AbstractMaybeWithUpstream(MaybeSource<T> source); @Override final MaybeSource<T> source(); }### Answer: @SuppressWarnings("unchecked") @Test public void upstream() { Maybe<Integer> source = Maybe.just(1); assertSame(source, ((HasUpstreamMaybeSource<Integer>)source.map(Functions.<Integer>identity())).source()); }
### Question: MaybeToObservable extends Observable<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToObservable(MaybeSource<T> source); @Override MaybeSource<T> source(); @SuppressWarnings({ "rawtypes", "unchecked" }) static Function<MaybeSource<T>, Observable<T>> instance(); }### Answer: @Test public void source() { Maybe<Integer> m = Maybe.just(1); assertSame(m, (((HasUpstreamMaybeSource<?>)m.toObservable()).source())); }
### Question: MaybeIsEmptySingle extends Single<Boolean> implements HasUpstreamMaybeSource<T>, FuseToMaybe<Boolean> { @Override public MaybeSource<T> source() { return source; } MaybeIsEmptySingle(MaybeSource<T> source); @Override MaybeSource<T> source(); @Override Maybe<Boolean> fuseToMaybe(); }### Answer: @Test public void source() { Maybe<Integer> m = Maybe.just(1); assertSame(m, (((HasUpstreamMaybeSource<?>)m.isEmpty()).source())); }
### Question: MaybeEmpty extends Maybe<Object> implements ScalarCallable<Object> { @Override public Object call() { return null; } @Override Object call(); static final MaybeEmpty INSTANCE; }### Answer: @Test public void scalarCallable() { Maybe<Integer> m = Maybe.empty(); assertTrue(m.getClass().toString(), m instanceof ScalarCallable); assertNull(((ScalarCallable<?>)m).call()); }
### Question: MaybeFromCallable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { return callable.call(); } MaybeFromCallable(Callable<? extends T> callable); @Override T call(); }### Answer: @SuppressWarnings("unchecked") @Test public void callable() throws Exception { final int[] counter = { 0 }; Maybe<Integer> m = Maybe.fromCallable(new Callable<Integer>() { @Override public Integer call() throws Exception { counter[0]++; return 0; } }); assertTrue(m.getClass().toString(), m instanceof Callable); assertEquals(0, ((Callable<Void>)m).call()); assertEquals(1, counter[0]); }
### Question: MaybeFromAction extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { action.run(); return null; } MaybeFromAction(Action action); @Override T call(); }### Answer: @SuppressWarnings("unchecked") @Test public void callable() throws Exception { final int[] counter = { 0 }; Maybe<Void> m = Maybe.fromAction(new Action() { @Override public void run() throws Exception { counter[0]++; } }); assertTrue(m.getClass().toString(), m instanceof Callable); assertNull(((Callable<Void>)m).call()); assertEquals(1, counter[0]); }
### Question: SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executor.get().schedule(task, delay, unit); } task.setFuture(f); return task; } catch (RejectedExecutionException ex) { RxJavaCommonPlugins.onError(ex); return REJECTED; } } SingleScheduler(); SingleScheduler(ThreadFactory threadFactory); @Override void start(); @Override void shutdown(); @NonNull @Override Worker createWorker(); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @Override Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit); }### Answer: @Test(timeout = 1000) public void runnableDisposedAsync() throws Exception { final Scheduler s = Schedulers.single(); Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE); while (!d.isDisposed()) { Thread.sleep(1); } } @Test(timeout = 1000) public void runnableDisposedAsyncCrash() throws Exception { final Scheduler s = Schedulers.single(); Disposable d = s.scheduleDirect(new Runnable() { @Override public void run() { throw new IllegalStateException(); } }); while (!d.isDisposed()) { Thread.sleep(1); } } @Test(timeout = 1000) public void runnableDisposedAsyncTimed() throws Exception { final Scheduler s = Schedulers.single(); Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MILLISECONDS); while (!d.isDisposed()) { Thread.sleep(1); } }
### Question: ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public ObservableSource<T> source() { return source; } private ObservablePublish(ObservableSource<T> onSubscribe, ObservableSource<T> source, final AtomicReference<PublishObserver<T>> current); static ConnectableObservable<T> create(ObservableSource<T> source); @Override ObservableSource<T> source(); @Override void connect(Consumer<? super Disposable> connection); }### Answer: @Test public void source() { Observable<Integer> o = Observable.never(); assertSame(o, (((HasUpstreamObservableSource<?>)o.publish()).source())); }
### Question: AbstractObservableWithUpstream extends Observable<U> implements HasUpstreamObservableSource<T> { @Override public final ObservableSource<T> source() { return source; } AbstractObservableWithUpstream(ObservableSource<T> source); @Override final ObservableSource<T> source(); }### Answer: @SuppressWarnings("unchecked") @Test public void source() { Observable<Integer> o = Observable.just(1); assertSame(o, ((HasUpstreamObservableSource<Integer>)o.map(Functions.<Integer>identity())).source()); }
### Question: ObservableFromIterable extends Observable<T> { public ObservableFromIterable(Iterable<? extends T> source) { this.source = source; } ObservableFromIterable(Iterable<? extends T> source); @Override void subscribeActual(Observer<? super T> s); }### Answer: @Test public void testObservableFromIterable() { Observable<String> o = Observable.fromIterable(Arrays.<String> asList("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, Mockito.never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
### Question: MaybeJust extends Maybe<T> implements ScalarCallable<T> { @Override public T call() { return value; } MaybeJust(T value); @Override T call(); }### Answer: @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()); }
### Question: 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(MaybeSource<T> source); @Override void onSubscribe(Disposable d); @SuppressWarnings("unchecked") @Override void onSuccess(T value); @SuppressWarnings("unchecked") @Override void onError(Throwable e); @SuppressWarnings("unchecked") @Override void onComplete(); }### Answer: @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.get()); assertTrue(pp.hasObservers()); source.test(true).assertEmpty(); ts.assertEmpty(); pp.onError(new TestException()); ts.assertFailure(TestException.class); source.test().assertFailure(TestException.class); source.test(true).assertEmpty(); } @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) throws Exception { ts.cancel(); } }); source.subscribe(ts); pp.onError(new TestException()); ts.assertEmpty(); }
### Question: MaybeFromRunnable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { runnable.run(); return null; } MaybeFromRunnable(Runnable runnable); @Override T call(); }### Answer: @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()); assertEquals(1, counter[0]); }
### Question: 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(Disposable d); @Override void onError(Throwable e); @Override void onComplete(); }### Answer: @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.ignoreElements().cache(); c.subscribe(ts2); c.subscribe(ts1); ps.onError(new TestException()); ts1.assertEmpty(); ts2.assertFailure(TestException.class); }
### Question: 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(); @Override boolean isDisposed(); @Override void onSubscribe(Disposable d); @Override void onSuccess(T value); @Override void onError(Throwable e); @Override void onComplete(); }### Answer: @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.isDisposed()); }
### Question: MaybeFromCompletable extends Maybe<T> implements HasUpstreamCompletableSource { @Override public CompletableSource source() { return source; } MaybeFromCompletable(CompletableSource source); @Override CompletableSource source(); }### Answer: @Test public void source() { Completable c = Completable.complete(); assertSame(c, ((HasUpstreamCompletableSource)Maybe.fromCompletable(c)).source()); }
### Question: 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 scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @Override Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit); }### Answer: @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(); try { sd.replace(w.schedulePeriodically(new Runnable() { int count; @Override public void run() { if (++count == 10) { sd.dispose(); cdl.countDown(); } } }, initial, 0, TimeUnit.MILLISECONDS)); assertTrue("" + initial, cdl.await(5, TimeUnit.SECONDS)); } finally { sd.dispose(); w.dispose(); } } }
### Question: 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; } private EndObserverHelper(); static boolean validate(Disposable upstream, Disposable next, Class<?> observer); static boolean setOnce(AtomicReference<Disposable> upstream, Disposable next, Class<?> observer); static String composeMessage(String consumer); static void reportDoubleSubscription(Class<?> consumer); }### Answer: @Test public void validateDisposable() { Disposable d1 = Disposables.empty(); assertFalse(EndObserverHelper.validate(DisposableHelper.DISPOSED, d1, getClass())); assertTrue(d1.isDisposed()); assertTrue(errors.toString(), errors.isEmpty()); }
### Question: 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, long delay, TimeUnit unit); @NonNull @Override Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit); @NonNull @Override Worker createWorker(); static final Scheduler INSTANCE; }### Answer: @Test public void scheduleDirect() { final int[] count = { 0 }; ImmediateThinScheduler.INSTANCE.scheduleDirect(new Runnable() { @Override public void run() { count[0]++; } }); assertEquals(1, count[0]); } @Test(expected = UnsupportedOperationException.class) public void scheduleDirectTimed() { ImmediateThinScheduler.INSTANCE.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.SECONDS); }
### Question: 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 @Override Disposable scheduleDirect(@NonNull Runnable run); @NonNull @Override Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit); @NonNull @Override Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit); @NonNull @Override Worker createWorker(); static final Scheduler INSTANCE; }### Answer: @Test(expected = UnsupportedOperationException.class) public void scheduleDirectPeriodic() { ImmediateThinScheduler.INSTANCE.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.SECONDS); }
### Question: 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(); @Override final boolean isDisposed(); }### Answer: @Test(expected = NullPointerException.class) public void nullResource() { TestResourceSubscriber<Integer> ro = new TestResourceSubscriber<Integer>(); ro.add(null); }
### Question: 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(); }### Answer: @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); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); }
### Question: 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 void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @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()); assertEquals(1, tc.start); TestCommonHelper.assertError(error, 0, IllegalStateException.class, EndSubscriberHelper.composeMessage(tc.getClass().getName())); } finally { RxJavaCommonPlugins.reset(); } }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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.complete); tc.requestMore(1); assertEquals(1, tc.start); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); assertEquals(1, tc.complete); }
### Question: 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 @Override Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit); @NonNull @Override Worker createWorker(); static final Scheduler INSTANCE; }### Answer: @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]); } @Test(expected = UnsupportedOperationException.class) public void scheduleTimed() { ImmediateThinScheduler.INSTANCE.createWorker().schedule(Functions.EMPTY_RUNNABLE, 1, TimeUnit.SECONDS); } @Test(expected = UnsupportedOperationException.class) public void schedulePeriodic() { ImmediateThinScheduler.INSTANCE.createWorker().schedulePeriodically(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.SECONDS); }
### Question: 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(); }### Answer: @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); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); }
### Question: 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(); }### Answer: @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()); assertEquals(1, tc.start); TestCommonHelper.assertError(error, 0, IllegalStateException.class, EndSubscriberHelper.composeMessage(tc.getClass().getName())); } finally { RxJavaCommonPlugins.reset(); } }
### Question: 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(); }### Answer: @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); }
### Question: 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); if (o != DisposableHelper.DISPOSED && o != null) { o.dispose(); } } } } } ArrayCompositeDisposable(int capacity); boolean setResource(int index, Disposable resource); Disposable replaceResource(int index, Disposable resource); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @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()); } }
### Question: 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<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void request(long n); @Override void cancel(); }### Answer: @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 BooleanSubscription(); so.onSubscribe(d); assertTrue(d.isCancelled()); TestCommonHelper.assertError(error, 0, IllegalStateException.class, "Subscription already set!"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: ReplayProcessor extends FlowableProcessor<T> { public Object[] getValues() { @SuppressWarnings("unchecked") T[] a = (T[])EMPTY_ARRAY; T[] b = getValues(a); if (b == EMPTY_ARRAY) { return new Object[0]; } return b; } @SuppressWarnings("unchecked") ReplayProcessor(ReplayBuffer<T> buffer); @CheckReturnValue static ReplayProcessor<T> create(); @CheckReturnValue static ReplayProcessor<T> create(int capacityHint); @CheckReturnValue static ReplayProcessor<T> createWithSize(int maxSize); @CheckReturnValue static ReplayProcessor<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplayProcessor<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void testGetValues() { ReplayProcessor<Object> rs = ReplayProcessor.create(); Object[] expected = new Object[10]; for (int i = 0; i < expected.length; i++) { expected[i] = i; rs.onNext(i); assertArrayEquals(Arrays.copyOf(expected, i + 1), rs.getValues()); } rs.onComplete(); assertArrayEquals(expected, rs.getValues()); }
### Question: ReplayProcessor extends FlowableProcessor<T> { @CheckReturnValue public static <T> ReplayProcessor<T> createWithSize(int maxSize) { return new ReplayProcessor<T>(new SizeBoundReplayBuffer<T>(maxSize)); } @SuppressWarnings("unchecked") ReplayProcessor(ReplayBuffer<T> buffer); @CheckReturnValue static ReplayProcessor<T> create(); @CheckReturnValue static ReplayProcessor<T> create(int capacityHint); @CheckReturnValue static ReplayProcessor<T> createWithSize(int maxSize); @CheckReturnValue static ReplayProcessor<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplayProcessor<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void createWithSizeInvalidCapacity() { try { ReplayProcessor.createWithSize(-99); fail("Didn't throw IllegalArgumentException"); } catch (IllegalArgumentException ex) { assertEquals("maxSize > 0 required but it was -99", ex.getMessage()); } }
### Question: ReplayProcessor extends FlowableProcessor<T> { @CheckReturnValue public static <T> ReplayProcessor<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize) { return new ReplayProcessor<T>(new SizeAndTimeBoundReplayBuffer<T>(maxSize, maxAge, unit, scheduler)); } @SuppressWarnings("unchecked") ReplayProcessor(ReplayBuffer<T> buffer); @CheckReturnValue static ReplayProcessor<T> create(); @CheckReturnValue static ReplayProcessor<T> create(int capacityHint); @CheckReturnValue static ReplayProcessor<T> createWithSize(int maxSize); @CheckReturnValue static ReplayProcessor<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplayProcessor<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void createWithTimeAndSizeInvalidCapacity() { try { ReplayProcessor.createWithTimeAndSize(1, TimeUnit.DAYS, Schedulers.computation(), -99); fail("Didn't throw IllegalArgumentException"); } catch (IllegalArgumentException ex) { assertEquals("maxSize > 0 required but it was -99", ex.getMessage()); } }
### Question: ReplayProcessor extends FlowableProcessor<T> { @Override public boolean hasSubscribers() { return subscribers.get().length != 0; } @SuppressWarnings("unchecked") ReplayProcessor(ReplayBuffer<T> buffer); @CheckReturnValue static ReplayProcessor<T> create(); @CheckReturnValue static ReplayProcessor<T> create(int capacityHint); @CheckReturnValue static ReplayProcessor<T> createWithSize(int maxSize); @CheckReturnValue static ReplayProcessor<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplayProcessor<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void hasSubscribers() { ReplayProcessor<Integer> rp = ReplayProcessor.create(); assertFalse(rp.hasSubscribers()); TestSubscriber<Integer> ts = rp.test(); assertTrue(rp.hasSubscribers()); ts.cancel(); assertFalse(rp.hasSubscribers()); }
### Question: AsyncProcessor extends FlowableProcessor<T> { @CheckReturnValue @NonNull public static <T> AsyncProcessor<T> create() { return new AsyncProcessor<T>(); } @SuppressWarnings("unchecked") AsyncProcessor(); @CheckReturnValue @NonNull static AsyncProcessor<T> create(); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); @Override boolean hasSubscribers(); @Override boolean hasThrowable(); @Override boolean hasComplete(); @Override Throwable getThrowable(); boolean hasValue(); T getValue(); Object[] getValues(); T[] getValues(T[] array); }### Answer: @Test public void cancelRace() { AsyncProcessor<Object> p = AsyncProcessor.create(); for (int i = 0; i < 500; i++) { final TestSubscriber<Object> ts1 = p.test(); final TestSubscriber<Object> ts2 = p.test(); Runnable r1 = new Runnable() { @Override public void run() { ts1.cancel(); } }; Runnable r2 = new Runnable() { @Override public void run() { ts2.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } }
### Question: ArrayCompositeDisposable extends AtomicReferenceArray<Disposable> implements Disposable { public Disposable replaceResource(int index, Disposable resource) { for (;;) { Disposable o = get(index); if (o == DisposableHelper.DISPOSED) { resource.dispose(); return null; } if (compareAndSet(index, o, resource)) { return o; } } } ArrayCompositeDisposable(int capacity); boolean setResource(int index, Disposable resource); Disposable replaceResource(int index, Disposable resource); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void replaceRace() { for (int i = 0; i < 100; i++) { final ArrayCompositeDisposable acd = new ArrayCompositeDisposable(2); Runnable r = new Runnable() { @Override public void run() { acd.replaceResource(0, Disposables.empty()); } }; TestCommonHelper.race(r, r, Schedulers.io()); } }
### Question: PublishProcessor extends FlowableProcessor<T> { @CheckReturnValue public static <T> PublishProcessor<T> create() { return new PublishProcessor<T>(); } @SuppressWarnings("unchecked") PublishProcessor(); @CheckReturnValue static PublishProcessor<T> create(); @Override void subscribeActual(Subscriber<? super T> t); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); boolean offer(T t); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); @Override boolean hasThrowable(); @Override boolean hasComplete(); }### Answer: @Test public void requestValidation() { TestHelper.assertBadRequestReported(PublishProcessor.create()); } @Test public void addRemoveRance() throws Exception { for (int i = 0; i < 100; i++) { final PublishProcessor<Integer> pp = PublishProcessor.create(); final TestSubscriber<Integer> ts = pp.test(); Runnable r1 = new Runnable() { @Override public void run() { pp.subscribe(); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.io()); } }
### Question: PublishProcessor extends FlowableProcessor<T> { public boolean offer(T t) { if (t == null) { onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return true; } PublishSubscription<T>[] array = subscribers.get(); for (PublishSubscription<T> s : array) { if (s.isFull()) { return false; } } for (PublishSubscription<T> s : array) { s.onNext(t); } return true; } @SuppressWarnings("unchecked") PublishProcessor(); @CheckReturnValue static PublishProcessor<T> create(); @Override void subscribeActual(Subscriber<? super T> t); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); boolean offer(T t); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); @Override boolean hasThrowable(); @Override boolean hasComplete(); }### Answer: @Test public void offer() { PublishProcessor<Integer> pp = PublishProcessor.create(); TestSubscriber<Integer> ts = pp.test(0); assertFalse(pp.offer(1)); ts.request(1); assertTrue(pp.offer(1)); assertFalse(pp.offer(2)); ts.cancel(); assertTrue(pp.offer(2)); ts = pp.test(0); assertTrue(pp.offer(null)); ts.assertFailure(NullPointerException.class); assertTrue(pp.hasThrowable()); assertTrue(pp.getThrowable().toString(), pp.getThrowable() instanceof NullPointerException); }
### Question: SerializedProcessor extends FlowableProcessor<T> { @Override public void onNext(T t) { if (done) { return; } synchronized (this) { if (done) { return; } if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(4); queue = q; } q.add(NotificationLite.next(t)); return; } emitting = true; } actual.onNext(t); emitLoop(); } SerializedProcessor(final FlowableProcessor<T> actual); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasSubscribers(); @Override boolean hasThrowable(); @Override Throwable getThrowable(); @Override boolean hasComplete(); }### Answer: @Test public void onNextOnNextRace() { for (int i = 0; i < 500; i++) { final FlowableProcessor<Integer> s = PublishProcessor.<Integer>create().toSerialized(); TestSubscriber<Integer> ts = s.test(); Runnable r1 = new Runnable() { @Override public void run() { s.onNext(1); } }; Runnable r2 = new Runnable() { @Override public void run() { s.onNext(2); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); ts.assertSubscribed().assertNoErrors().assertNotComplete() .assertValueSet(Arrays.asList(1, 2)); } }
### Question: SerializedProcessor extends FlowableProcessor<T> { @Override public void onComplete() { if (done) { return; } synchronized (this) { if (done) { return; } done = true; if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(4); queue = q; } q.add(NotificationLite.complete()); return; } emitting = true; } actual.onComplete(); } SerializedProcessor(final FlowableProcessor<T> actual); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasSubscribers(); @Override boolean hasThrowable(); @Override Throwable getThrowable(); @Override boolean hasComplete(); }### Answer: @Test public void onCompleteOnCompleteRace() { for (int i = 0; i < 500; i++) { final FlowableProcessor<Integer> s = PublishProcessor.<Integer>create().toSerialized(); TestSubscriber<Integer> ts = s.test(); Runnable r1 = new Runnable() { @Override public void run() { s.onComplete(); } }; Runnable r2 = new Runnable() { @Override public void run() { s.onComplete(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); ts.assertResult(); } }
### Question: SerializedProcessor extends FlowableProcessor<T> { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } boolean reportError; synchronized (this) { if (done) { reportError = true; } else { done = true; if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(4); queue = q; } q.setFirst(NotificationLite.error(t)); return; } reportError = false; emitting = true; } } if (reportError) { RxJavaCommonPlugins.onError(t); return; } actual.onError(t); } SerializedProcessor(final FlowableProcessor<T> actual); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasSubscribers(); @Override boolean hasThrowable(); @Override Throwable getThrowable(); @Override boolean hasComplete(); }### Answer: @Test public void onErrorOnErrorRace() { for (int i = 0; i < 500; i++) { final FlowableProcessor<Integer> s = PublishProcessor.<Integer>create().toSerialized(); TestSubscriber<Integer> ts = s.test(); final TestException ex = new TestException(); List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { Runnable r1 = new Runnable() { @Override public void run() { s.onError(ex); } }; Runnable r2 = new Runnable() { @Override public void run() { s.onError(ex); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); ts.assertFailure(TestException.class); TestCommonHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaCommonPlugins.reset(); } } }
### Question: SerializedProcessor extends FlowableProcessor<T> { @Override public void onSubscribe(Subscription s) { boolean cancel; if (!done) { synchronized (this) { if (done) { cancel = true; } else { if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(4); queue = q; } q.add(NotificationLite.subscription(s)); return; } emitting = true; cancel = false; } } } else { cancel = true; } if (cancel) { s.cancel(); } else { actual.onSubscribe(s); emitLoop(); } } SerializedProcessor(final FlowableProcessor<T> actual); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasSubscribers(); @Override boolean hasThrowable(); @Override Throwable getThrowable(); @Override boolean hasComplete(); }### Answer: @Test public void onSubscribeOnSubscribeRace() { for (int i = 0; i < 500; i++) { final FlowableProcessor<Integer> s = PublishProcessor.<Integer>create().toSerialized(); TestSubscriber<Integer> ts = s.test(); final BooleanSubscription bs1 = new BooleanSubscription(); final BooleanSubscription bs2 = new BooleanSubscription(); Runnable r1 = new Runnable() { @Override public void run() { s.onSubscribe(bs1); } }; Runnable r2 = new Runnable() { @Override public void run() { s.onSubscribe(bs2); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); ts.assertEmpty(); } }
### Question: BehaviorProcessor extends FlowableProcessor<T> { @Override public void onSubscribe(Subscription s) { if (terminalEvent.get() != null) { s.cancel(); return; } s.request(Long.MAX_VALUE); } @SuppressWarnings("unchecked") BehaviorProcessor(); BehaviorProcessor(T defaultValue); @CheckReturnValue static BehaviorProcessor<T> create(); @CheckReturnValue static BehaviorProcessor<T> createDefault(T defaultValue); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); boolean offer(T t); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); @SuppressWarnings("unchecked") T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void onSubscribe() { BehaviorProcessor<Object> p = BehaviorProcessor.create(); BooleanSubscription bs = new BooleanSubscription(); p.onSubscribe(bs); assertFalse(bs.isCancelled()); p.onComplete(); bs = new BooleanSubscription(); p.onSubscribe(bs); assertTrue(bs.isCancelled()); }
### Question: BehaviorProcessor extends FlowableProcessor<T> { @CheckReturnValue public static <T> BehaviorProcessor<T> create() { return new BehaviorProcessor<T>(); } @SuppressWarnings("unchecked") BehaviorProcessor(); BehaviorProcessor(T defaultValue); @CheckReturnValue static BehaviorProcessor<T> create(); @CheckReturnValue static BehaviorProcessor<T> createDefault(T defaultValue); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); boolean offer(T t); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); @SuppressWarnings("unchecked") T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void addRemoveRace() { for (int i = 0; i < 500; i++) { final BehaviorProcessor<Object> p = BehaviorProcessor.create(); final TestSubscriber<Object> ts = p.test(); Runnable r1 = new Runnable() { @Override public void run() { p.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } }
### Question: BehaviorProcessor extends FlowableProcessor<T> { public boolean offer(T t) { if (t == null) { onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return true; } BehaviorSubscription<T>[] array = subscribers.get(); for (BehaviorSubscription<T> s : array) { if (s.isFull()) { return false; } } Object o = NotificationLite.next(t); setCurrent(o); for (BehaviorSubscription<T> bs : array) { bs.emitNext(o, index); } return true; } @SuppressWarnings("unchecked") BehaviorProcessor(); BehaviorProcessor(T defaultValue); @CheckReturnValue static BehaviorProcessor<T> create(); @CheckReturnValue static BehaviorProcessor<T> createDefault(T defaultValue); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); boolean offer(T t); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); @SuppressWarnings("unchecked") T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void offer() { BehaviorProcessor<Integer> pp = BehaviorProcessor.create(); TestSubscriber<Integer> ts = pp.test(0); assertFalse(pp.offer(1)); ts.request(1); assertTrue(pp.offer(1)); assertFalse(pp.offer(2)); ts.cancel(); assertTrue(pp.offer(2)); ts = pp.test(1); assertTrue(pp.offer(null)); ts.assertFailure(NullPointerException.class, 2); assertTrue(pp.hasThrowable()); assertTrue(pp.getThrowable().toString(), pp.getThrowable() instanceof NullPointerException); }
### Question: ArrayCompositeDisposable extends AtomicReferenceArray<Disposable> implements Disposable { public boolean setResource(int index, Disposable resource) { for (;;) { Disposable o = get(index); if (o == DisposableHelper.DISPOSED) { resource.dispose(); return false; } if (compareAndSet(index, o, resource)) { if (o != null) { o.dispose(); } return true; } } } ArrayCompositeDisposable(int capacity); boolean setResource(int index, Disposable resource); Disposable replaceResource(int index, Disposable resource); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void setRace() { for (int i = 0; i < 100; i++) { final ArrayCompositeDisposable acd = new ArrayCompositeDisposable(2); Runnable r = new Runnable() { @Override public void run() { acd.setResource(0, Disposables.empty()); } }; TestCommonHelper.race(r, r, Schedulers.io()); } }
### Question: DeferredScalarSubscription extends BasicIntFusedQueueSubscription<T> { @Override public final int requestFusion(int mode) { if ((mode & ASYNC) != 0) { lazySet(FUSED_EMPTY); return ASYNC; } return NONE; } DeferredScalarSubscription(Subscriber<? super T> actual); @Override final void request(long n); final void complete(T v); @Override final int requestFusion(int mode); @Nullable @Override final T poll(); @Override final boolean isEmpty(); @Override final void clear(); @Override void cancel(); final boolean isCancelled(); final boolean tryCancel(); }### Answer: @Test public void FusedQueueSubscriptionSyncRejected() { DeferredScalarSubscription<Integer> ds = new DeferredScalarSubscription<Integer>(new TestSubscriber<Integer>()); assertEquals(FusedQueueSubscription.NONE, ds.requestFusion(FusedQueueSubscription.SYNC)); }
### Question: DeferredScalarSubscription extends BasicIntFusedQueueSubscription<T> { @Override public final void clear() { lazySet(FUSED_CONSUMED); value = null; } DeferredScalarSubscription(Subscriber<? super T> actual); @Override final void request(long n); final void complete(T v); @Override final int requestFusion(int mode); @Nullable @Override final T poll(); @Override final boolean isEmpty(); @Override final void clear(); @Override void cancel(); final boolean isCancelled(); final boolean tryCancel(); }### Answer: @Test public void clear() { DeferredScalarSubscription<Integer> ds = new DeferredScalarSubscription<Integer>(new TestSubscriber<Integer>()); ds.value = 1; ds.clear(); assertEquals(DeferredScalarSubscription.FUSED_CONSUMED, ds.get()); assertNull(ds.value); }
### Question: DeferredScalarSubscription extends BasicIntFusedQueueSubscription<T> { @Override public void cancel() { set(CANCELLED); value = null; } DeferredScalarSubscription(Subscriber<? super T> actual); @Override final void request(long n); final void complete(T v); @Override final int requestFusion(int mode); @Nullable @Override final T poll(); @Override final boolean isEmpty(); @Override final void clear(); @Override void cancel(); final boolean isCancelled(); final boolean tryCancel(); }### Answer: @Test public void cancel() { DeferredScalarSubscription<Integer> ds = new DeferredScalarSubscription<Integer>(new TestSubscriber<Integer>()); assertTrue(ds.tryCancel()); assertFalse(ds.tryCancel()); }
### Question: ArrayCompositeSubscription extends AtomicReferenceArray<Subscription> implements Disposable { @Override public void dispose() { if (get(0) != SubscriptionHelper.CANCELLED) { int s = length(); for (int i = 0; i < s; i++) { Subscription o = get(i); if (o != SubscriptionHelper.CANCELLED) { o = getAndSet(i, SubscriptionHelper.CANCELLED); if (o != SubscriptionHelper.CANCELLED && o != null) { o.cancel(); } } } } } ArrayCompositeSubscription(int capacity); boolean setResource(int index, Subscription resource); Subscription replaceResource(int index, Subscription resource); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void disposeRace() { for (int i = 0; i < 500; i++) { final ArrayCompositeSubscription ac = new ArrayCompositeSubscription(1000); Runnable r = new Runnable() { @Override public void run() { ac.dispose(); } }; TestCommonHelper.race(r, r, Schedulers.single()); } }
### Question: CancellableDisposable extends AtomicReference<Cancellable> implements Disposable { @Override public void dispose() { if (get() != null) { Cancellable c = getAndSet(null); if (c != null) { try { c.cancel(); } catch (Exception ex) { Exceptions.throwIfFatal(ex); RxJavaCommonPlugins.onError(ex); } } } } CancellableDisposable(Cancellable cancellable); @Override boolean isDisposed(); @Override void dispose(); }### Answer: @Test public void disposeRace() { for (int i = 0; i < 100; i++) { final AtomicInteger count = new AtomicInteger(); Cancellable c = new Cancellable() { @Override public void cancel() throws Exception { count.getAndIncrement(); } }; final CancellableDisposable cd = new CancellableDisposable(c); Runnable r = new Runnable() { @Override public void run() { cd.dispose(); } }; TestCommonHelper.race(r, r, Schedulers.io()); assertEquals(1, count.get()); } }
### Question: FullArbiter extends FullArbiterPad2 implements Subscription { @Override public void request(long n) { if (SubscriptionHelper.validate(n)) { BackpressureHelper.add(missedRequested, n); queue.offer(REQUEST, REQUEST); drain(); } } FullArbiter(Subscriber<? super T> actual, Disposable resource, int capacity); @Override void request(long n); @Override void cancel(); boolean setSubscription(Subscription s); boolean onNext(T value, Subscription s); void onError(Throwable value, Subscription s); void onComplete(Subscription s); }### Answer: @Test public void initialRequested() { FullArbiter.INITIAL.request(-99); } @Test public void invalidDeferredRequest() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { new FullArbiter<Integer>(new TestSubscriber<Integer>(), null, 128).request(-99); TestCommonHelper.assertError(errors, 0, IllegalArgumentException.class, "n > 0 required but it was -99"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: FullArbiter extends FullArbiterPad2 implements Subscription { @Override public void cancel() { if (!cancelled) { cancelled = true; dispose(); } } FullArbiter(Subscriber<? super T> actual, Disposable resource, int capacity); @Override void request(long n); @Override void cancel(); boolean setSubscription(Subscription s); boolean onNext(T value, Subscription s); void onError(Throwable value, Subscription s); void onComplete(Subscription s); }### Answer: @Test public void initialCancel() { FullArbiter.INITIAL.cancel(); }
### Question: ScalarSubscription extends AtomicInteger implements FusedQueueSubscription<T> { @Override public void request(long n) { if (!SubscriptionHelper.validate(n)) { return; } if (compareAndSet(NO_REQUEST, REQUESTED)) { Subscriber<? super T> s = subscriber; s.onNext(value); if (get() != CANCELLED) { s.onComplete(); } } } ScalarSubscription(Subscriber<? super T> subscriber, T value); @Override void request(long n); @Override void cancel(); boolean isCancelled(); @Override boolean offer(T e); @Nullable @Override T poll(); @Override boolean isEmpty(); @Override void clear(); @Override int requestFusion(int mode); }### Answer: @Test public void badRequest() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); ScalarSubscription<Integer> sc = new ScalarSubscription<Integer>(ts, 1); List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { sc.request(-99); TestCommonHelper.assertError(errors, 0, IllegalArgumentException.class, "n > 0 required but it was -99"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: AsyncSubscription extends AtomicLong implements Subscription, Disposable { public boolean setResource(Disposable r) { return DisposableHelper.set(resource, r); } AsyncSubscription(); AsyncSubscription(Disposable resource); @Override void request(long n); @Override void cancel(); @Override void dispose(); @Override boolean isDisposed(); boolean setResource(Disposable r); boolean replaceResource(Disposable r); void setSubscription(Subscription s); }### Answer: @Test public void testSetResource() { AsyncSubscription as = new AsyncSubscription(); Disposable r = mock(Disposable.class); assertTrue(as.setResource(r)); as.cancel(); verify(r).dispose(); }
### Question: AsyncSubscription extends AtomicLong implements Subscription, Disposable { public boolean replaceResource(Disposable r) { return DisposableHelper.replace(resource, r); } AsyncSubscription(); AsyncSubscription(Disposable resource); @Override void request(long n); @Override void cancel(); @Override void dispose(); @Override boolean isDisposed(); boolean setResource(Disposable r); boolean replaceResource(Disposable r); void setSubscription(Subscription s); }### Answer: @Test public void testReplaceResource() { AsyncSubscription as = new AsyncSubscription(); Disposable r = mock(Disposable.class); assertTrue(as.replaceResource(r)); as.cancel(); verify(r).dispose(); }
### Question: SubscriptionArbiter extends AtomicInteger implements Subscription { @Override public final void request(long n) { if (SubscriptionHelper.validate(n)) { if (unbounded) { return; } if (get() == 0 && compareAndSet(0, 1)) { long r = requested; if (r != Long.MAX_VALUE) { r = BackpressureHelper.addCap(r, n); requested = r; if (r == Long.MAX_VALUE) { unbounded = true; } } Subscription a = actual; if (decrementAndGet() != 0) { drainLoop(); } if (a != null) { a.request(n); } return; } BackpressureHelper.add(missedRequested, n); drain(); } } SubscriptionArbiter(); final void setSubscription(Subscription s); @Override final void request(long n); final void produced(long n); @Override void cancel(); final boolean isUnbounded(); final boolean isCancelled(); }### Answer: @Test public void invalidDeferredRequest() { SubscriptionArbiter sa = new SubscriptionArbiter(); List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { sa.request(-99); TestCommonHelper.assertError(errors, 0, IllegalArgumentException.class, "n > 0 required but it was -99"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: ListCompositeDisposable implements Disposable, DisposableContainer { @Override public void dispose() { if (disposed) { return; } List<Disposable> set; synchronized (this) { if (disposed) { return; } disposed = true; set = resources; resources = null; } dispose(set); } ListCompositeDisposable(); ListCompositeDisposable(Disposable... resources); ListCompositeDisposable(Iterable<? extends Disposable> resources); @Override void dispose(); @Override boolean isDisposed(); @Override boolean add(Disposable d); boolean addAll(Disposable... ds); @Override boolean remove(Disposable d); @Override boolean delete(Disposable d); void clear(); }### Answer: @Test public void disposeThrows() { Disposable d = new Disposable() { @Override public void dispose() { throw new TestException(); } @Override public boolean isDisposed() { return false; } }; ListCompositeDisposable lcd = new ListCompositeDisposable(d, d); try { lcd.dispose(); fail("Should have thrown!"); } catch (CompositeException ex) { List<Throwable> list = ex.getExceptions(); TestCommonHelper.assertError(list, 0, TestException.class); TestCommonHelper.assertError(list, 1, TestException.class); } lcd = new ListCompositeDisposable(d); try { lcd.dispose(); fail("Should have thrown!"); } catch (TestException ex) { } } @Test public void disposeRace() { for (int i = 0; i < 500; i++) { final ListCompositeDisposable cd = new ListCompositeDisposable(); Runnable run = new Runnable() { @Override public void run() { cd.dispose(); } }; TestCommonHelper.race(run, run, Schedulers.io()); } }
### Question: LambdaSubscriber extends AtomicReference<Subscription> implements RelaxedSubscriber<T>, Subscription, Disposable { @Override public boolean isDisposed() { return get() == SubscriptionHelper.CANCELLED; } LambdaSubscriber(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Subscription> onSubscribe); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); @Override void request(long n); @Override void cancel(); }### Answer: @Test public void onSubscribeThrows() { final List<Object> received = new ArrayList<Object>(); LambdaSubscriber<Object> o = new LambdaSubscriber<Object>(new Consumer<Object>() { @Override public void accept(Object v) throws Exception { received.add(v); } }, new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { received.add(e); } }, new Action() { @Override public void run() throws Exception { received.add(100); } }, new Consumer<Subscription>() { @Override public void accept(Subscription s) throws Exception { throw new TestException(); } }); assertFalse(o.isDisposed()); Flowable.just(1).subscribe(o); assertTrue(received.toString(), received.get(0) instanceof TestException); assertEquals(received.toString(), 1, received.size()); assertTrue(o.isDisposed()); }
### Question: LambdaSubscriber extends AtomicReference<Subscription> implements RelaxedSubscriber<T>, Subscription, Disposable { @Override public void onNext(T t) { if (!isDisposed()) { try { onNext.accept(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); get().cancel(); onError(e); } } } LambdaSubscriber(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Subscription> onSubscribe); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); @Override void request(long n); @Override void cancel(); }### Answer: @Test public void onNextThrowsCancelsUpstream() { PublishProcessor<Integer> ps = PublishProcessor.create(); final List<Throwable> errors = new ArrayList<Throwable>(); ps.subscribe(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { throw new TestException(); } }, new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { errors.add(e); } }); assertTrue("No observers?!", ps.hasSubscribers()); assertTrue("Has errors already?!", errors.isEmpty()); ps.onNext(1); assertFalse("Has observers?!", ps.hasSubscribers()); assertFalse("No errors?!", errors.isEmpty()); assertTrue(errors.toString(), errors.get(0) instanceof TestException); }
### Question: DeferredScalarSubscriber extends DeferredScalarSubscription<R> implements RelaxedSubscriber<T> { @Override public void onError(Throwable t) { value = null; actual.onError(t); } DeferredScalarSubscriber(Subscriber<? super R> actual); @Override void onSubscribe(Subscription s); @Override void onError(Throwable t); @Override void onComplete(); @Override void cancel(); }### Answer: @Test public void error() { TestSubscriber<Integer> ts = TestSubscriber.create(0L); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ts.assertNoValues(); ds.onError(new TestException()); ts.assertNoValues(); ts.assertError(TestException.class); ts.assertNotComplete(); }
### Question: ListCompositeDisposable implements Disposable, DisposableContainer { @Override public boolean remove(Disposable d) { if (delete(d)) { d.dispose(); return true; } return false; } ListCompositeDisposable(); ListCompositeDisposable(Disposable... resources); ListCompositeDisposable(Iterable<? extends Disposable> resources); @Override void dispose(); @Override boolean isDisposed(); @Override boolean add(Disposable d); boolean addAll(Disposable... ds); @Override boolean remove(Disposable d); @Override boolean delete(Disposable d); void clear(); }### Answer: @Test public void remove() { ListCompositeDisposable lcd = new ListCompositeDisposable(); Disposable d = Disposables.empty(); lcd.add(d); assertTrue(lcd.delete(d)); assertFalse(d.isDisposed()); lcd.add(d); assertTrue(lcd.remove(d)); assertTrue(d.isDisposed()); assertFalse(lcd.remove(d)); assertFalse(lcd.delete(d)); lcd = new ListCompositeDisposable(); assertFalse(lcd.remove(d)); assertFalse(lcd.delete(d)); }
### Question: StrictSubscriber extends AtomicInteger implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (once.compareAndSet(false, true)) { actual.onSubscribe(this); SubscriptionHelper.deferredSetOnce(this.s, requested, s); } else { s.cancel(); cancel(); onError(new IllegalStateException("§2.12 violated: onSubscribe must be called at most once")); } } StrictSubscriber(Subscriber<? super T> actual); @Override void request(long n); @Override void cancel(); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); }### Answer: @Test public void doubleOnSubscribe() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SubscriberWrapper<Integer> wrapper = new SubscriberWrapper<Integer>(ts); new Flowable<Integer>() { @Override protected void subscribeActual(Subscriber<? super Integer> s) { BooleanSubscription b1 = new BooleanSubscription(); s.onSubscribe(b1); BooleanSubscription b2 = new BooleanSubscription(); s.onSubscribe(b2); assertTrue(b1.isCancelled()); assertTrue(b2.isCancelled()); } }.subscribe(wrapper); ts.assertFailure(IllegalStateException.class); assertTrue(ts.errors().toString(), ts.errors().get(0).getMessage().contains("2.12")); }
### Question: FutureSubscriber extends CountDownLatch implements RelaxedSubscriber<T>, Future<T>, Subscription { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Subscription a = s.get(); if (a == this \|\| a == SubscriptionHelper.CANCELLED) { return false; } if (s.compareAndSet(a, SubscriptionHelper.CANCELLED)) { if (a != null) { a.cancel(); } countDown(); return true; } } } FutureSubscriber(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void cancel(); @Override void request(long n); }### Answer: @Test public void cancel() throws Exception { assertFalse(fs.isDone()); assertFalse(fs.isCancelled()); fs.cancel(); fs.cancel(); fs.request(10); fs.request(-99); fs.cancel(false); assertTrue(fs.isDone()); assertTrue(fs.isCancelled()); try { fs.get(); fail("Should have thrown"); } catch (CancellationException ex) { } try { fs.get(1, TimeUnit.MILLISECONDS); fail("Should have thrown"); } catch (CancellationException ex) { } } @Test public void cancelRace() { for (int i = 0; i < 500; i++) { final FutureSubscriber<Integer> fs = new FutureSubscriber<Integer>(); Runnable r = new Runnable() { @Override public void run() { fs.cancel(false); } }; TestCommonHelper.race(r, r, Schedulers.single()); } }
### Question: FutureSubscriber extends CountDownLatch implements RelaxedSubscriber<T>, Future<T>, Subscription { @Override public void onError(Throwable t) { for (;;) { Subscription a = s.get(); if (a == this \|\| a == SubscriptionHelper.CANCELLED) { RxJavaCommonPlugins.onError(t); return; } error = t; if (s.compareAndSet(a, this)) { countDown(); return; } } } FutureSubscriber(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void cancel(); @Override void request(long n); }### Answer: @Test public void onError() throws Exception { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { fs.onError(new TestException("One")); fs.onError(new TestException("Two")); try { fs.get(5, TimeUnit.MILLISECONDS); } catch (ExecutionException ex) { assertTrue(ex.toString(), ex.getCause() instanceof TestException); assertEquals("One", ex.getCause().getMessage()); } TestCommonHelper.assertUndeliverable(errors, 0, TestException.class, "Two"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: FutureSubscriber extends CountDownLatch implements RelaxedSubscriber<T>, Future<T>, Subscription { @Override public void onNext(T t) { if (value != null) { s.get().cancel(); onError(new IndexOutOfBoundsException("More than one element received")); return; } value = t; } FutureSubscriber(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void cancel(); @Override void request(long n); }### Answer: @Test public void onNext() throws Exception { fs.onNext(1); fs.onComplete(); assertEquals(1, fs.get(5, TimeUnit.MILLISECONDS).intValue()); }
### Question: FutureSubscriber extends CountDownLatch implements RelaxedSubscriber<T>, Future<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.setOnce(this.s, s)) { s.request(Long.MAX_VALUE); } } FutureSubscriber(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void cancel(); @Override void request(long n); }### Answer: @Test public void onSubscribe() throws Exception { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { BooleanSubscription s = new BooleanSubscription(); fs.onSubscribe(s); BooleanSubscription s2 = new BooleanSubscription(); fs.onSubscribe(s2); assertFalse(s.isCancelled()); assertTrue(s2.isCancelled()); TestCommonHelper.assertError(errors, 0, IllegalStateException.class, "Subscription already set!"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: BlockingSubscriber extends AtomicReference<Subscription> implements RelaxedSubscriber<T>, Subscription { @Override public void cancel() { if (SubscriptionHelper.cancel(this)) { queue.offer(TERMINATED); } } BlockingSubscriber(Queue<Object> queue); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void request(long n); @Override void cancel(); boolean isCancelled(); static final Object TERMINATED; }### Answer: @Test public void cancel() { BlockingSubscriber<Integer> bq = new BlockingSubscriber<Integer>(new ArrayDeque<Object>()); assertFalse(bq.isCancelled()); bq.cancel(); assertTrue(bq.isCancelled()); bq.cancel(); assertTrue(bq.isCancelled()); }
### Question: BlockingSubscriber extends AtomicReference<Subscription> implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.setOnce(this, s)) { queue.offer(NotificationLite.subscription(this)); } } BlockingSubscriber(Queue<Object> queue); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void request(long n); @Override void cancel(); boolean isCancelled(); static final Object TERMINATED; }### Answer: @Test(timeout = 5000) public void blockingFirstTimeout2() { BlockingFirstSubscriber<Integer> bf = new BlockingFirstSubscriber<Integer>(); bf.onSubscribe(new BooleanSubscription()); Thread.currentThread().interrupt(); try { bf.blockingGet(); fail("Should have thrown!"); } catch (RuntimeException ex) { assertTrue(ex.toString(), ex.getCause() instanceof InterruptedException); } } @Test public void cancelOnRequest() { final BlockingFirstSubscriber<Integer> bf = new BlockingFirstSubscriber<Integer>(); final AtomicBoolean b = new AtomicBoolean(); Subscription s = new Subscription() { @Override public void request(long n) { bf.cancelled = true; } @Override public void cancel() { b.set(true); } }; bf.onSubscribe(s); assertTrue(b.get()); } @Test public void cancelUpfront() { final BlockingFirstSubscriber<Integer> bf = new BlockingFirstSubscriber<Integer>(); final AtomicBoolean b = new AtomicBoolean(); bf.cancelled = true; Subscription s = new Subscription() { @Override public void request(long n) { b.set(true); } @Override public void cancel() { } }; bf.onSubscribe(s); assertFalse(b.get()); }
### Question: SubscriberResourceWrapper extends AtomicReference<Disposable> implements RelaxedSubscriber<T>, Disposable, Subscription { @Override public void cancel() { dispose(); } SubscriberResourceWrapper(Subscriber<? super T> actual); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void request(long n); @Override void dispose(); @Override boolean isDisposed(); @Override void cancel(); void setResource(Disposable resource); }### Answer: @Test public void cancel() { BooleanSubscription bs = new BooleanSubscription(); Disposable d = Disposables.empty(); s.setResource(d); s.onSubscribe(bs); assertFalse(d.isDisposed()); assertFalse(s.isDisposed()); ts.cancel(); assertTrue(bs.isCancelled()); assertTrue(d.isDisposed()); assertTrue(s.isDisposed()); }
### Question: ListCompositeDisposable implements Disposable, DisposableContainer { @Override public boolean add(Disposable d) { ObjectHelper.requireNonNull(d, "d is null"); if (!disposed) { synchronized (this) { if (!disposed) { List<Disposable> set = resources; if (set == null) { set = new LinkedList<Disposable>(); resources = set; } set.add(d); return true; } } } d.dispose(); return false; } ListCompositeDisposable(); ListCompositeDisposable(Disposable... resources); ListCompositeDisposable(Iterable<? extends Disposable> resources); @Override void dispose(); @Override boolean isDisposed(); @Override boolean add(Disposable d); boolean addAll(Disposable... ds); @Override boolean remove(Disposable d); @Override boolean delete(Disposable d); void clear(); }### Answer: @Test public void addRace() { for (int i = 0; i < 500; i++) { final ListCompositeDisposable cd = new ListCompositeDisposable(); Runnable run = new Runnable() { @Override public void run() { cd.add(Disposables.empty()); } }; TestCommonHelper.race(run, run, Schedulers.io()); } }
### Question: FlowableReplay extends ConnectableFlowable<T> implements HasUpstreamPublisher<T>, Disposable { @Override public void dispose() { current.lazySet(null); } private FlowableReplay(Publisher<T> onSubscribe, Flowable<T> source, final AtomicReference<ReplaySubscriber<T>> current, final Callable<? extends ReplayBuffer<T>> bufferFactory); static Flowable<R> multicastSelector( final Callable<? extends ConnectableFlowable<U>> connectableFactory, final Function<? super Flowable<U>, ? extends Publisher<R>> selector); static ConnectableFlowable<T> observeOn(final ConnectableFlowable<T> co, final Scheduler scheduler); @SuppressWarnings("unchecked") static ConnectableFlowable<T> createFrom(Flowable<? extends T> source); static ConnectableFlowable<T> create(Flowable<T> source, final int bufferSize); static ConnectableFlowable<T> create(Flowable<T> source, long maxAge, TimeUnit unit, Scheduler scheduler); static ConnectableFlowable<T> create(Flowable<T> source, final long maxAge, final TimeUnit unit, final Scheduler scheduler, final int bufferSize); @Override Publisher<T> source(); @Override void dispose(); @Override boolean isDisposed(); @Override void connect(Consumer<? super Disposable> connection); }### Answer: @Test public void testColdReplayBackpressure() { Flowable<Integer> source = Flowable.range(0, 1000).replay().autoConnect(); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); ts.request(10); source.subscribe(ts); ts.assertNoErrors(); ts.assertNotComplete(); List<Integer> onNextEvents = ts.values(); assertEquals(10, onNextEvents.size()); for (int i = 0; i < 10; i++) { assertEquals((Integer)i, onNextEvents.get(i)); } ts.dispose(); }
### Question: FlowableReplay extends ConnectableFlowable<T> implements HasUpstreamPublisher<T>, Disposable { @Override public Publisher<T> source() { return source; } private FlowableReplay(Publisher<T> onSubscribe, Flowable<T> source, final AtomicReference<ReplaySubscriber<T>> current, final Callable<? extends ReplayBuffer<T>> bufferFactory); static Flowable<R> multicastSelector( final Callable<? extends ConnectableFlowable<U>> connectableFactory, final Function<? super Flowable<U>, ? extends Publisher<R>> selector); static ConnectableFlowable<T> observeOn(final ConnectableFlowable<T> co, final Scheduler scheduler); @SuppressWarnings("unchecked") static ConnectableFlowable<T> createFrom(Flowable<? extends T> source); static ConnectableFlowable<T> create(Flowable<T> source, final int bufferSize); static ConnectableFlowable<T> create(Flowable<T> source, long maxAge, TimeUnit unit, Scheduler scheduler); static ConnectableFlowable<T> create(Flowable<T> source, final long maxAge, final TimeUnit unit, final Scheduler scheduler, final int bufferSize); @Override Publisher<T> source(); @Override void dispose(); @Override boolean isDisposed(); @Override void connect(Consumer<? super Disposable> connection); }### Answer: @Test public void source() { Flowable<Integer> source = Flowable.range(1, 3); assertSame(source, (((HasUpstreamPublisher<?>)source.replay())).source()); }
### Question: ListCompositeDisposable implements Disposable, DisposableContainer { public boolean addAll(Disposable... ds) { ObjectHelper.requireNonNull(ds, "ds is null"); if (!disposed) { synchronized (this) { if (!disposed) { List<Disposable> set = resources; if (set == null) { set = new LinkedList<Disposable>(); resources = set; } for (Disposable d : ds) { ObjectHelper.requireNonNull(d, "d is null"); set.add(d); } return true; } } } for (Disposable d : ds) { d.dispose(); } return false; } ListCompositeDisposable(); ListCompositeDisposable(Disposable... resources); ListCompositeDisposable(Iterable<? extends Disposable> resources); @Override void dispose(); @Override boolean isDisposed(); @Override boolean add(Disposable d); boolean addAll(Disposable... ds); @Override boolean remove(Disposable d); @Override boolean delete(Disposable d); void clear(); }### Answer: @Test public void addAllRace() { for (int i = 0; i < 500; i++) { final ListCompositeDisposable cd = new ListCompositeDisposable(); Runnable run = new Runnable() { @Override public void run() { cd.addAll(Disposables.empty()); } }; TestCommonHelper.race(run, run, Schedulers.io()); } }
### Question: ExceptionHelper { public static <T> boolean addThrowable(AtomicReference<Throwable> field, Throwable exception) { for (;;) { Throwable current = field.get(); if (current == TERMINATED) { return false; } Throwable update; if (current == null) { update = exception; } else { update = new CompositeException(current, exception); } if (field.compareAndSet(current, update)) { return true; } } } private ExceptionHelper(); static RuntimeException wrapOrThrow(Throwable error); static boolean addThrowable(AtomicReference<Throwable> field, Throwable exception); static Throwable terminate(AtomicReference<Throwable> field); static List<Throwable> flatten(Throwable t); @SuppressWarnings("unchecked") static Exception throwIfThrowable(Throwable e); static final Throwable TERMINATED; }### Answer: @Test public void addRace() { for (int i = 0; i < 500; i++) { final AtomicReference<Throwable> error = new AtomicReference<Throwable>(); final TestException ex = new TestException(); Runnable r = new Runnable() { @Override public void run() { assertTrue(ExceptionHelper.addThrowable(error, ex)); } }; TestCommonHelper.race(r, r, Schedulers.single()); } }
### Question: ExceptionHelper { @SuppressWarnings("unchecked") public static <E extends Throwable> Exception throwIfThrowable(Throwable e) throws E { if (e instanceof Exception) { return (Exception)e; } throw (E)e; } private ExceptionHelper(); static RuntimeException wrapOrThrow(Throwable error); static boolean addThrowable(AtomicReference<Throwable> field, Throwable exception); static Throwable terminate(AtomicReference<Throwable> field); static List<Throwable> flatten(Throwable t); @SuppressWarnings("unchecked") static Exception throwIfThrowable(Throwable e); static final Throwable TERMINATED; }### Answer: @Test(expected = InternalError.class) public void throwIfThrowable() throws Exception { ExceptionHelper.<Exception>throwIfThrowable(new InternalError()); }
### Question: AtomicThrowable extends AtomicReference<Throwable> { public boolean isTerminated() { return get() == ExceptionHelper.TERMINATED; } boolean addThrowable(Throwable t); Throwable terminate(); boolean isTerminated(); }### Answer: @Test public void isTerminated() { AtomicThrowable ex = new AtomicThrowable(); assertFalse(ex.isTerminated()); assertNull(ex.terminate()); assertTrue(ex.isTerminated()); }
### Question: BlockingHelper { public static void awaitForComplete(CountDownLatch latch, Disposable subscription) { if (latch.getCount() == 0) { return; } try { verifyNonBlocking(); latch.await(); } catch (InterruptedException e) { subscription.dispose(); Thread.currentThread().interrupt(); throw new IllegalStateException("Interrupted while waiting for subscription to complete.", e); } } private BlockingHelper(); static void awaitForComplete(CountDownLatch latch, Disposable subscription); static void verifyNonBlocking(); }### Answer: @Test public void interrupted() { CountDownLatch cdl = new CountDownLatch(1); Disposable d = Disposables.empty(); Thread.currentThread().interrupt(); try { BlockingHelper.awaitForComplete(cdl, d); } catch (IllegalStateException ex) { } assertTrue(d.isDisposed()); assertTrue(Thread.interrupted()); } @Test public void unblock() { final CountDownLatch cdl = new CountDownLatch(1); Disposable d = Disposables.empty(); Schedulers.computation().scheduleDirect(new Runnable() { @Override public void run() { cdl.countDown(); } }, 100, TimeUnit.MILLISECONDS); BlockingHelper.awaitForComplete(cdl, d); assertFalse(d.isDisposed()); }
### Question: FlowableScalarXMap { public static <T, U> Flowable<U> scalarXMap(final T value, final Function<? super T, ? extends Publisher<? extends U>> mapper) { return RxJavaFlowablePlugins.onAssembly(new ScalarXMapFlowable<T, U>(value, mapper)); } private FlowableScalarXMap(); @SuppressWarnings("unchecked") static boolean tryScalarXMapSubscribe(Publisher<T> source, Subscriber<? super R> subscriber, Function<? super T, ? extends Publisher<? extends R>> mapper); static Flowable<U> scalarXMap(final T value, final Function<? super T, ? extends Publisher<? extends U>> mapper); }### Answer: @Test public void scalarMapToEmpty() { FlowableScalarXMap.scalarXMap(1, new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer v) throws Exception { return Flowable.empty(); } }) .test() .assertResult(); } @Test public void scalarMapToCrashingCallable() { FlowableScalarXMap.scalarXMap(1, new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer v) throws Exception { return new CallablePublisher(); } }) .test() .assertFailure(TestException.class); }
### Question: ObjectHelper { public static int hashCode(Object o) { return o != null ? o.hashCode() : 0; } private ObjectHelper(); static T requireNonNull(T object, String message); static boolean equals(Object o1, Object o2); static int hashCode(Object o); static int compare(int v1, int v2); static int compare(long v1, long v2); @SuppressWarnings("unchecked") static BiPredicate<T, T> equalsPredicate(); static int verifyPositive(int value, String paramName); static long verifyPositive(long value, String paramName); }### Answer: @Test public void hashCodeOf() { assertEquals(0, ObjectHelper.hashCode(null)); assertEquals(((Integer)1).hashCode(), ObjectHelper.hashCode(1)); }
### Question: ObjectHelper { public static int verifyPositive(int value, String paramName) { if (value <= 0) { throw new IllegalArgumentException(paramName + " > 0 required but it was " + value); } return value; } private ObjectHelper(); static T requireNonNull(T object, String message); static boolean equals(Object o1, Object o2); static int hashCode(Object o); static int compare(int v1, int v2); static int compare(long v1, long v2); @SuppressWarnings("unchecked") static BiPredicate<T, T> equalsPredicate(); static int verifyPositive(int value, String paramName); static long verifyPositive(long value, String paramName); }### Answer: @Test public void verifyPositiveInt() throws Exception { assertEquals(1, ObjectHelper.verifyPositive(1, "param")); } @Test public void verifyPositiveLong() throws Exception { assertEquals(1L, ObjectHelper.verifyPositive(1L, "param")); } @Test(expected = IllegalArgumentException.class) public void verifyPositiveIntFail() throws Exception { assertEquals(-1, ObjectHelper.verifyPositive(-1, "param")); } @Test(expected = IllegalArgumentException.class) public void verifyPositiveLongFail() throws Exception { assertEquals(-1L, ObjectHelper.verifyPositive(-1L, "param")); }
### Question: FlowablePublish extends ConnectableFlowable<T> implements HasUpstreamPublisher<T> { @Override public Publisher<T> source() { return source; } private FlowablePublish(Publisher<T> onSubscribe, Flowable<T> source, final AtomicReference<PublishSubscriber<T>> current, int bufferSize); static ConnectableFlowable<T> create(Flowable<T> source, final int bufferSize); @Override Publisher<T> source(); @Override void connect(Consumer<? super Disposable> connection); }### Answer: @Test public void source() { Flowable<Integer> o = Flowable.never(); assertSame(o, (((HasUpstreamPublisher<?>)o.publish()).source())); }
### Question: ObjectHelper { public static int compare(int v1, int v2) { return v1 < v2 ? -1 : (v1 > v2 ? 1 : 0); } private ObjectHelper(); static T requireNonNull(T object, String message); static boolean equals(Object o1, Object o2); static int hashCode(Object o); static int compare(int v1, int v2); static int compare(long v1, long v2); @SuppressWarnings("unchecked") static BiPredicate<T, T> equalsPredicate(); static int verifyPositive(int value, String paramName); static long verifyPositive(long value, String paramName); }### Answer: @Test public void compare() { assertEquals(-1, ObjectHelper.compare(0, 2)); assertEquals(0, ObjectHelper.compare(0, 0)); assertEquals(1, ObjectHelper.compare(2, 0)); }
### Question: FlowableCache extends AbstractFlowableWithUpstream<T, T> { boolean hasSubscribers() { return state.subscribers.get().length != 0; } FlowableCache(Flowable<T> source, int capacityHint); }### Answer: @Test public void testTake() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); FlowableCache<Integer> cached = new FlowableCache<Integer>(Flowable.range(1, 100), 16); cached.take(10).subscribe(ts); ts.assertNoErrors(); ts.assertComplete(); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); assertFalse(cached.hasSubscribers()); }
### Question: AbstractFlowableWithUpstream extends Flowable<R> implements HasUpstreamPublisher<T> { @Override public final Publisher<T> source() { return source; } AbstractFlowableWithUpstream(Flowable<T> source); @Override final Publisher<T> source(); }### Answer: @SuppressWarnings("unchecked") @Test public void source() { Flowable<Integer> o = Flowable.just(1); assertSame(o, ((HasUpstreamPublisher<Integer>)o.map(Functions.<Integer>identity())).source()); }
### Question: FlowableRefCount extends AbstractFlowableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Subscriber<? super T> subscriber, final AtomicBoolean writeLocked) { return new DisposeConsumer(subscriber, writeLocked); } FlowableRefCount(ConnectableFlowable<T> source); @Override void subscribeActual(final Subscriber<? super T> subscriber); }### Answer: @Test public void onlyFirstShouldSubscribeAndLastUnsubscribe() { final AtomicInteger subscriptionCount = new AtomicInteger(); final AtomicInteger unsubscriptionCount = new AtomicInteger(); Flowable<Integer> observable = Flowable.unsafeCreate(new Publisher<Integer>() { @Override public void subscribe(Subscriber<? super Integer> observer) { subscriptionCount.incrementAndGet(); observer.onSubscribe(new Subscription() { @Override public void request(long n) { } @Override public void cancel() { unsubscriptionCount.incrementAndGet(); } }); } }); Flowable<Integer> refCounted = observable.publish().refCount(); Disposable first = refCounted.subscribe(); assertEquals(1, subscriptionCount.get()); Disposable second = refCounted.subscribe(); assertEquals(1, subscriptionCount.get()); first.dispose(); assertEquals(0, unsubscriptionCount.get()); second.dispose(); assertEquals(1, unsubscriptionCount.get()); } @Test public void noOpConnect() { final int[] calls = { 0 }; Flowable<Integer> o = new ConnectableFlowable<Integer>() { @Override public void connect(Consumer<? super Disposable> connection) { calls[0]++; } @Override protected void subscribeActual(Subscriber<? super Integer> observer) { observer.onSubscribe(new BooleanSubscription()); } }.refCount(); o.test(); o.test(); assertEquals(1, calls[0]); }
### Question: BackpressureHelper { public static long addCap(long a, long b) { long u = a + b; if (u < 0L) { return Long.MAX_VALUE; } return u; } private BackpressureHelper(); static long addCap(long a, long b); static long multiplyCap(long a, long b); static long add(AtomicLong requested, long n); static long addCancel(AtomicLong requested, long n); static long produced(AtomicLong requested, long n); static long producedCancel(AtomicLong requested, long n); }### Answer: @Test public void testAddCap() { assertEquals(2L, BackpressureHelper.addCap(1, 1)); assertEquals(Long.MAX_VALUE, BackpressureHelper.addCap(1, Long.MAX_VALUE - 1)); assertEquals(Long.MAX_VALUE, BackpressureHelper.addCap(1, Long.MAX_VALUE)); assertEquals(Long.MAX_VALUE, BackpressureHelper.addCap(Long.MAX_VALUE - 1, Long.MAX_VALUE - 1)); assertEquals(Long.MAX_VALUE, BackpressureHelper.addCap(Long.MAX_VALUE, Long.MAX_VALUE)); }
### Question: BackpressureHelper { public static long multiplyCap(long a, long b) { long u = a * b; if (((a \| b) >>> 31) != 0) { if (u / a != b) { return Long.MAX_VALUE; } } return u; } private BackpressureHelper(); static long addCap(long a, long b); static long multiplyCap(long a, long b); static long add(AtomicLong requested, long n); static long addCancel(AtomicLong requested, long n); static long produced(AtomicLong requested, long n); static long producedCancel(AtomicLong requested, long n); }### Answer: @Test public void testMultiplyCap() { assertEquals(6, BackpressureHelper.multiplyCap(2, 3)); assertEquals(Long.MAX_VALUE, BackpressureHelper.multiplyCap(2, Long.MAX_VALUE)); assertEquals(Long.MAX_VALUE, BackpressureHelper.multiplyCap(Long.MAX_VALUE, Long.MAX_VALUE)); assertEquals(Long.MAX_VALUE, BackpressureHelper.multiplyCap(1L << 32, 1L << 32)); } @Test public void multiplyCap() { assertEquals(Long.MAX_VALUE, BackpressureHelper.multiplyCap(3, Long.MAX_VALUE >> 1)); assertEquals(Long.MAX_VALUE, BackpressureHelper.multiplyCap(1, Long.MAX_VALUE)); }
### Question: BackpressureHelper { public static long produced(AtomicLong requested, long n) { for (;;) { long current = requested.get(); if (current == Long.MAX_VALUE) { return Long.MAX_VALUE; } long update = current - n; if (update < 0L) { RxJavaCommonPlugins.onError(new IllegalStateException("More produced than requested: " + update)); update = 0L; } if (requested.compareAndSet(current, update)) { return update; } } } private BackpressureHelper(); static long addCap(long a, long b); static long multiplyCap(long a, long b); static long add(AtomicLong requested, long n); static long addCancel(AtomicLong requested, long n); static long produced(AtomicLong requested, long n); static long producedCancel(AtomicLong requested, long n); }### Answer: @Test public void producedMore() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { AtomicLong requested = new AtomicLong(1); assertEquals(0, BackpressureHelper.produced(requested, 2)); TestCommonHelper.assertError(list, 0, IllegalStateException.class, "More produced than requested: -1"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: BackpressureHelper { public static long producedCancel(AtomicLong requested, long n) { for (;;) { long current = requested.get(); if (current == Long.MIN_VALUE) { return Long.MIN_VALUE; } if (current == Long.MAX_VALUE) { return Long.MAX_VALUE; } long update = current - n; if (update < 0L) { RxJavaCommonPlugins.onError(new IllegalStateException("More produced than requested: " + update)); update = 0L; } if (requested.compareAndSet(current, update)) { return update; } } } private BackpressureHelper(); static long addCap(long a, long b); static long multiplyCap(long a, long b); static long add(AtomicLong requested, long n); static long addCancel(AtomicLong requested, long n); static long produced(AtomicLong requested, long n); static long producedCancel(AtomicLong requested, long n); }### Answer: @Test public void producedMoreCancel() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { AtomicLong requested = new AtomicLong(1); assertEquals(0, BackpressureHelper.producedCancel(requested, 2)); TestCommonHelper.assertError(list, 0, IllegalStateException.class, "More produced than requested: -1"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: EndSubscriberHelper { public static boolean validate(Subscription upstream, Subscription next, Class<?> subscriber) { ObjectHelper.requireNonNull(next, "next is null"); if (upstream != null) { next.cancel(); if (upstream != SubscriptionHelper.CANCELLED) { reportDoubleSubscription(subscriber); } return false; } return true; } private EndSubscriberHelper(); static boolean validate(Subscription upstream, Subscription next, Class<?> subscriber); static boolean setOnce(AtomicReference<Subscription> upstream, Subscription next, Class<?> subscriber); static String composeMessage(String consumer); static void reportDoubleSubscription(Class<?> consumer); }### Answer: @Test public void validateSubscription() { BooleanSubscription d1 = new BooleanSubscription(); assertFalse(EndSubscriberHelper.validate(SubscriptionHelper.CANCELLED, d1, getClass())); assertTrue(d1.isCancelled()); assertTrue(errors.toString(), errors.isEmpty()); }
### Question: QueueDrainHelper { static boolean isCancelled(BooleanSupplier cancelled) { try { return cancelled.getAsBoolean(); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); return true; } } private QueueDrainHelper(); static void drainMaxLoop(SimplePlainQueue<T> q, Subscriber<? super U> a, boolean delayError, Disposable dispose, QueueDrain<T, U> qd); static boolean checkTerminated(boolean d, boolean empty, Subscriber<?> s, boolean delayError, FusedQueue<?> q, QueueDrain<T, U> qd); static FusedQueue<T> createQueue(int capacityHint); static void request(Subscription s, int prefetch); static boolean postCompleteRequest(long n, Subscriber<? super T> actual, Queue<T> queue, AtomicLong state, BooleanSupplier isCancelled); static void postComplete(Subscriber<? super T> actual, Queue<T> queue, AtomicLong state, BooleanSupplier isCancelled); }### Answer: @Test public void isCancelled() { assertTrue(QueueDrainHelper.isCancelled(new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { throw new IOException(); } })); }
### Question: QueueDrainHelper { public static void request(Subscription s, int prefetch) { s.request(prefetch < 0 ? Long.MAX_VALUE : prefetch); } private QueueDrainHelper(); static void drainMaxLoop(SimplePlainQueue<T> q, Subscriber<? super U> a, boolean delayError, Disposable dispose, QueueDrain<T, U> qd); static boolean checkTerminated(boolean d, boolean empty, Subscriber<?> s, boolean delayError, FusedQueue<?> q, QueueDrain<T, U> qd); static FusedQueue<T> createQueue(int capacityHint); static void request(Subscription s, int prefetch); static boolean postCompleteRequest(long n, Subscriber<? super T> actual, Queue<T> queue, AtomicLong state, BooleanSupplier isCancelled); static void postComplete(Subscriber<? super T> actual, Queue<T> queue, AtomicLong state, BooleanSupplier isCancelled); }### Answer: @Test public void requestMaxInt() { QueueDrainHelper.request(new Subscription() { @Override public void request(long n) { assertEquals(Integer.MAX_VALUE, n); } @Override public void cancel() { } }, Integer.MAX_VALUE); } @Test public void requestMinInt() { QueueDrainHelper.request(new Subscription() { @Override public void request(long n) { assertEquals(Long.MAX_VALUE, n); } @Override public void cancel() { } }, Integer.MIN_VALUE); } @Test public void requestAlmostMaxInt() { QueueDrainHelper.request(new Subscription() { @Override public void request(long n) { assertEquals(Integer.MAX_VALUE - 1, n); } @Override public void cancel() { } }, Integer.MAX_VALUE - 1); }
### Question: MaybeToFlowable extends Flowable<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToFlowable(MaybeSource<T> source); @Override MaybeSource<T> source(); }### Answer: @Test public void source() { Maybe<Integer> m = Maybe.just(1); assertSame(m, (((HasUpstreamMaybeSource<?>)toFlowable(m)).source())); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.