Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
Single implements SingleSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> amb(final Iterable<? extends SingleSource<? extends T>> sources); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<T> ambArray(final SingleSource<? extends T>... sources); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observable<T> concat(Iterable<? extends SingleSource<? extends T>> sources); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings({ "unchecked", "rawtypes" }) static Observable<T> concat(ObservableSource<? extends SingleSource<? extends T>> sources); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings({ "unchecked", "rawtypes" }) static Observable<T> concat(ObservableSource<? extends SingleSource<? extends T>> sources, int prefetch); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Observable<T> concat( SingleSource<? extends T> source1, SingleSource<? extends T> source2 ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Observable<T> concat( SingleSource<? extends T> source1, SingleSource<? extends T> source2, SingleSource<? extends T> source3 ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Observable<T> concat( SingleSource<? extends T> source1, SingleSource<? extends T> source2, SingleSource<? extends T> source3, SingleSource<? extends T> source4 ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings({ "unchecked", "rawtypes" }) static Observable<T> concatArray(SingleSource<? extends T>... sources); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> create(SingleOnSubscribe<T> source); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> defer(final Callable<? extends SingleSource<? extends T>> singleSupplier); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> error(final Callable<? extends Throwable> errorSupplier); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> error(final Throwable exception); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> fromCallable(final Callable<? extends T> callable); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> fromFuture(Future<? extends T> future); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) static Single<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit, Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) static Single<T> fromFuture(Future<? extends T> future, Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> fromObservable(ObservableSource<? extends T> observableSource); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> just(final T item); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Observable<T> merge(Iterable<? extends SingleSource<? extends T>> sources); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings({ "unchecked", "rawtypes" }) static Observable<T> merge(ObservableSource<? extends SingleSource<? extends T>> sources); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings({ "unchecked", "rawtypes" }) static Single<T> merge(SingleSource<? extends SingleSource<? extends T>> source); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Observable<T> merge( SingleSource<? extends T> source1, SingleSource<? extends T> source2 ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Observable<T> merge( SingleSource<? extends T> source1, SingleSource<? extends T> source2, SingleSource<? extends T> source3 ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Observable<T> merge( SingleSource<? extends T> source1, SingleSource<? extends T> source2, SingleSource<? extends T> source3, SingleSource<? extends T> source4 ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<T> never(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) static Single<Long> timer(long delay, TimeUnit unit); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) static Single<Long> timer(final long delay, final TimeUnit unit, final Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<Boolean> equals(final SingleSource<? extends T> first, final SingleSource<? extends T> second); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> unsafeCreate(SingleSource<T> onSubscribe); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> using(Callable<U> resourceSupplier, Function<? super U, ? extends SingleSource<? extends T>> singleFunction, Consumer<? super U> disposer); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> using( final Callable<U> resourceSupplier, final Function<? super U, ? extends SingleSource<? extends T>> singleFunction, final Consumer<? super U> disposer, final boolean eager); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<T> wrap(SingleSource<T> source); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<R> zip(final Iterable<? extends SingleSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<R> zip( SingleSource<? extends T1> source1, SingleSource<? extends T2> source2, BiFunction<? super T1, ? super T2, ? extends R> zipper ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<R> zip( SingleSource<? extends T1> source1, SingleSource<? extends T2> source2, SingleSource<? extends T3> source3, Function3<? super T1, ? super T2, ? super T3, ? extends R> zipper ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<R> zip( SingleSource<? extends T1> source1, SingleSource<? extends T2> source2, SingleSource<? extends T3> source3, SingleSource<? extends T4> source4, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> zipper ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<R> zip( SingleSource<? extends T1> source1, SingleSource<? extends T2> source2, SingleSource<? extends T3> source3, SingleSource<? extends T4> source4, SingleSource<? extends T5> source5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> zipper ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<R> zip( SingleSource<? extends T1> source1, SingleSource<? extends T2> source2, SingleSource<? extends T3> source3, SingleSource<? extends T4> source4, SingleSource<? extends T5> source5, SingleSource<? extends T6> source6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> zipper ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<R> zip( SingleSource<? extends T1> source1, SingleSource<? extends T2> source2, SingleSource<? extends T3> source3, SingleSource<? extends T4> source4, SingleSource<? extends T5> source5, SingleSource<? extends T6> source6, SingleSource<? extends T7> source7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> zipper ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<R> zip( SingleSource<? extends T1> source1, SingleSource<? extends T2> source2, SingleSource<? extends T3> source3, SingleSource<? extends T4> source4, SingleSource<? extends T5> source5, SingleSource<? extends T6> source6, SingleSource<? extends T7> source7, SingleSource<? extends T8> source8, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> zipper ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") static Single<R> zip( SingleSource<? extends T1> source1, SingleSource<? extends T2> source2, SingleSource<? extends T3> source3, SingleSource<? extends T4> source4, SingleSource<? extends T5> source5, SingleSource<? extends T6> source6, SingleSource<? extends T7> source7, SingleSource<? extends T8> source8, SingleSource<? extends T9> source9, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> zipper ); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Single<R> zipArray(Function<? super Object[], ? extends R> zipper, SingleSource<? extends T>... sources); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") final Single<T> ambWith(SingleSource<? extends T> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> hide(); @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<R> compose(SingleTransformer<? super T, ? extends R> transformer); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> cache(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<U> cast(final Class<? extends U> clazz); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Observable<T> concatWith(SingleSource<? extends T> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) final Single<T> delay(long time, TimeUnit unit); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) final Single<T> delay(final long time, final TimeUnit unit, final Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> delaySubscription(CompletableSource other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> delaySubscription(SingleSource<U> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> delaySubscription(ObservableSource<U> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) final Single<T> delaySubscription(long time, TimeUnit unit); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) final Single<T> delaySubscription(long time, TimeUnit unit, Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> doAfterSuccess(Consumer<? super T> onAfterSuccess); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> doAfterTerminate(Action onAfterTerminate); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> doFinally(Action onFinally); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> doOnSubscribe(final Consumer<? super Disposable> onSubscribe); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> doOnSuccess(final Consumer<? super T> onSuccess); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> doOnEvent(final BiConsumer<? super T, ? super Throwable> onEvent); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> doOnError(final Consumer<? super Throwable> onError); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> doOnDispose(final Action onDispose); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Maybe<T> filter(Predicate<? super T> predicate); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<R> flatMap(Function<? super T, ? extends SingleSource<? extends R>> mapper); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Maybe<R> flatMapMaybe(final Function<? super T, ? extends MaybeSource<? extends R>> mapper); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Observable<U> flattenAsObservable(final Function<? super T, ? extends Iterable<? extends U>> mapper); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Observable<R> flatMapObservable(Function<? super T, ? extends ObservableSource<? extends R>> mapper); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Completable flatMapCompletable(final Function<? super T, ? extends CompletableSource> mapper); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final T blockingGet(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<R> lift(final SingleOperator<? extends R, ? super T> lift); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<R> map(Function<? super T, ? extends R> mapper); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<Boolean> contains(Object value); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<Boolean> contains(final Object value, final BiPredicate<Object, Object> comparer); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Observable<T> mergeWith(SingleSource<? extends T> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) final Single<T> observeOn(final Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> onErrorReturn(final Function<Throwable, ? extends T> resumeFunction); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> onErrorReturnItem(final T value); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> onErrorResumeNext(final Single<? extends T> resumeSingleInCaseOfError); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> onErrorResumeNext( final Function<? super Throwable, ? extends SingleSource<? extends T>> resumeFunctionInCaseOfError); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Observable<T> repeat(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Observable<T> repeat(long times); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Observable<T> repeatWhen(Function<? super Observable<Object>, ? extends ObservableSource<?>> handler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Observable<T> repeatUntil(BooleanSupplier stop); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> retry(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> retry(long times); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> retry(BiPredicate<? super Integer, ? super Throwable> predicate); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> retry(Predicate<? super Throwable> predicate); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> retryWhen(Function<? super Observable<Throwable>, ? extends ObservableSource<?>> handler); @SchedulerSupport(SchedulerSupport.NONE) final Disposable subscribe(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Disposable subscribe(final BiConsumer<? super T, ? super Throwable> onCallback); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Disposable subscribe(Consumer<? super T> onSuccess); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Disposable subscribe(final Consumer<? super T> onSuccess, final Consumer<? super Throwable> onError); @SchedulerSupport(SchedulerSupport.NONE) @Override final void subscribe(SingleObserver<? super T> subscriber); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final E subscribeWith(E observer); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) final Single<T> subscribeOn(final Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> takeUntil(final CompletableSource other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> takeUntil(final ObservableSource<E> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<T> takeUntil(final SingleSource<? extends E> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) final Single<T> timeout(long timeout, TimeUnit unit); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) final Single<T> timeout(long timeout, TimeUnit unit, Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) final Single<T> timeout(long timeout, TimeUnit unit, Scheduler scheduler, SingleSource<? extends T> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) final Single<T> timeout(long timeout, TimeUnit unit, SingleSource<? extends T> other); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final R to(Function<? super Single<T>, R> convert); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Completable toCompletable(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Future<T> toFuture(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") final Maybe<T> toMaybe(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") final Observable<T> toObservable(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) final Single<T> unsubscribeOn(final Scheduler scheduler); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final Single<R> zipWith(SingleSource<U> other, BiFunction<? super T, ? super U, ? extends R> zipper); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final TestObserver<T> test(); @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) final TestObserver<T> test(boolean cancelled); }
@Test(expected = NullPointerException.class) public void implementationThrows() { new Single<Integer>() { @Override protected void subscribeActual(SingleObserver<? super Integer> observer) { throw new NullPointerException(); } }.test(); }
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(); }
@Test(expected = NullPointerException.class) public void nullResource() { TestResourceSubscriber<Integer> ro = new TestResourceSubscriber<Integer>(); ro.add(null); }
ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return SubscriptionHelper.isCancelled(s.get()); } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed(); }
@Test public void 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()); }
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(); }
@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(); } }
ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { if (SubscriptionHelper.cancel(s)) { resources.dispose(); } } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed(); }
@Test public void dispose() { TestResourceSubscriber<Integer> tc = new TestResourceSubscriber<Integer>(); tc.dispose(); BooleanSubscription d = new BooleanSubscription(); tc.onSubscribe(d); assertTrue(d.isCancelled()); assertEquals(0, tc.start); }
ResourceSubscriber implements RelaxedSubscriber<T>, Disposable { protected final void request(long n) { SubscriptionHelper.deferredRequest(s, missedRequested, n); } final void add(Disposable resource); @Override final void onSubscribe(Subscription s); @Override final void dispose(); @Override final boolean isDisposed(); }
@Test public void 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); }
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; }
@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); }
DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == SubscriptionHelper.CANCELLED; } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); }
@Test public void 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()); }
DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void onSubscribe(Subscription s) { if (EndSubscriberHelper.setOnce(this.s, s, getClass())) { onStart(); } } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); }
@Test public void 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(); } }
DisposableSubscriber implements RelaxedSubscriber<T>, Disposable { @Override public final void dispose() { SubscriptionHelper.cancel(s); } @Override final void onSubscribe(Subscription s); @Override final boolean isDisposed(); @Override final void dispose(); }
@Test public void 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); }
SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."); try { s.cancel(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); onError(new CompositeException(ex, e1)); return; } onError(ex); return; } try { actual.onNext(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); try { s.cancel(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); onError(new CompositeException(e, e1)); return; } onError(e); } } SafeSubscriber(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 cancel(); }
@Test public void onNextFailure() { AtomicReference<Throwable> onError = new AtomicReference<Throwable>(); try { OBSERVER_ONNEXT_FAIL(onError).onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { assertNull(onError.get()); assertTrue(e instanceof SafeSubscriberTestException); assertEquals("onNextFail", e.getMessage()); } } @Test public void onNextOnErrorFailure() { try { OBSERVER_ONNEXT_ONERROR_FAIL().onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof SafeSubscriberTestException); assertEquals("onNextFail", e.getMessage()); } } @Test @Ignore("Observers can't throw") public void onNextOnErrorFailureSafe() { try { new SafeSubscriber<String>(OBSERVER_ONNEXT_ONERROR_FAIL()).onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof RuntimeException); assertEquals("Error occurred when trying to propagate error to Subscriber.onError", e.getMessage()); Throwable e2 = e.getCause(); assertTrue(e2 instanceof CompositeException); List<Throwable> innerExceptions = ((CompositeException) e2).getExceptions(); assertEquals(2, innerExceptions.size()); Throwable e3 = innerExceptions.get(0); assertTrue(e3 instanceof SafeSubscriberTestException); assertEquals("onNextFail", e3.getMessage()); Throwable e4 = innerExceptions.get(1); assertTrue(e4 instanceof SafeSubscriberTestException); assertEquals("onErrorFail", e4.getMessage()); } } @Test public void onNextWithoutOnSubscribe() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SafeSubscriber<Integer> so = new SafeSubscriber<Integer>(ts); so.onNext(1); ts.assertFailureAndMessage(NullPointerException.class, "Subscription not set!"); } @Test public void onNextOnSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onNext(1); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class, "onSubscribe()"); } finally { RxJavaCommonPlugins.reset(); } } @Test public void noSubscribeOnErrorCrashes() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onNext(1); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class, "onError(java.lang.NullPointerException: Subscription not set!)"); } finally { RxJavaCommonPlugins.reset(); } }
SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeSubscriber(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 cancel(); }
@Test public void onCompleteFailure() { AtomicReference<Throwable> onError = new AtomicReference<Throwable>(); try { OBSERVER_ONCOMPLETED_FAIL(onError).onComplete(); fail("expects exception to be thrown"); } catch (Exception e) { assertNull(onError.get()); assertTrue(e instanceof SafeSubscriberTestException); assertEquals("onCompleteFail", e.getMessage()); } } @Test @Ignore("Observers can't throw") public void testOnCompletedThrows() { final AtomicReference<Throwable> error = new AtomicReference<Throwable>(); SafeSubscriber<Integer> s = new SafeSubscriber<Integer>(new DefaultSubscriber<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Throwable e) { error.set(e); } @Override public void onComplete() { throw new TestException(); } }); try { s.onComplete(); Assert.fail(); } catch (RuntimeException e) { assertNull(error.get()); } } @Test public void onCompleteWithoutOnSubscribe() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SafeSubscriber<Integer> so = new SafeSubscriber<Integer>(ts); so.onComplete(); ts.assertFailureAndMessage(NullPointerException.class, "Subscription not set!"); } @Test public void onCompleteteNoSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, true, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onComplete(); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class, "onSubscribe()"); } finally { RxJavaCommonPlugins.reset(); } } @Test public void onCompleteteNoSubscribeOnErrorCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, true, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onComplete(); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class); } finally { RxJavaCommonPlugins.reset(); } }
SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onError(Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptySubscription.INSTANCE); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(new CompositeException(t, npe, e)); return; } try { actual.onError(new CompositeException(t, npe)); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(new CompositeException(t, npe, e)); } return; } if (t == null) { t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources."); } try { actual.onError(t); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); RxJavaCommonPlugins.onError(new CompositeException(t, ex)); } } SafeSubscriber(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 cancel(); }
@Test public void onErrorFailure() { try { OBSERVER_ONERROR_FAIL().onError(new SafeSubscriberTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { assertTrue(e instanceof SafeSubscriberTestException); assertEquals("onErrorFail", e.getMessage()); } } @Test @Ignore("Observers can't throw") public void onErrorFailureSafe() { try { new SafeSubscriber<String>(OBSERVER_ONERROR_FAIL()).onError(new SafeSubscriberTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof RuntimeException); assertEquals("Error occurred when trying to propagate error to Subscriber.onError", e.getMessage()); Throwable e2 = e.getCause(); assertTrue(e2 instanceof CompositeException); List<Throwable> innerExceptions = ((CompositeException) e2).getExceptions(); assertEquals(2, innerExceptions.size()); Throwable e3 = innerExceptions.get(0); assertTrue(e3 instanceof SafeSubscriberTestException); assertEquals("error!", e3.getMessage()); Throwable e4 = innerExceptions.get(1); assertTrue(e4 instanceof SafeSubscriberTestException); assertEquals("onErrorFail", e4.getMessage()); } } @Test @Ignore("Observers can't throw") public void onErrorNotImplementedFailureSafe() { try { new SafeSubscriber<String>(OBSERVER_ONERROR_NOTIMPLEMENTED()).onError(new SafeSubscriberTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { assertTrue(e.getCause() instanceof SafeSubscriberTestException); assertEquals("error!", e.getCause().getMessage()); } } @Test public void onErrorWithoutOnSubscribe() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SafeSubscriber<Integer> so = new SafeSubscriber<Integer>(ts); so.onError(new TestException()); ts.assertFailure(CompositeException.class); TestHelper.assertError(ts, 0, TestException.class); TestHelper.assertError(ts, 1, NullPointerException.class, "Subscription not set!"); } @Test public void onErrorNoSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onError(new TestException()); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, TestException.class); TestCommonHelper.assertError(ce, 1, NullPointerException.class, "Subscription not set!"); } finally { RxJavaCommonPlugins.reset(); } } @Test public void onErrorNoSubscribeOnErrorCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onError(new TestException()); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, TestException.class); TestCommonHelper.assertError(ce, 1, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 2, TestException.class); } finally { RxJavaCommonPlugins.reset(); } }
SafeSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { actual.onSubscribe(this); } catch (Throwable e) { Exceptions.throwIfFatal(e); done = true; try { s.cancel(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); RxJavaCommonPlugins.onError(new CompositeException(e, e1)); return; } RxJavaCommonPlugins.onError(e); } } } SafeSubscriber(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 cancel(); }
@Test public void dispose() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); SafeSubscriber<Integer> so = new SafeSubscriber<Integer>(ts); BooleanSubscription d = new BooleanSubscription(); so.onSubscribe(d); ts.dispose(); assertTrue(d.isCancelled()); } @Test public void onSubscribeTwice() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onSubscribe(cd); so.onSubscribe(cd); TestCommonHelper.assertError(list, 0, IllegalStateException.class); } finally { RxJavaCommonPlugins.reset(); } } @Test public void onSubscribeCrashes() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false, false); SafeSubscriber<Object> so = cd.toSafe(); so.onSubscribe(cd); TestCommonHelper.assertUndeliverable(list, 0, TestException.class, "onSubscribe()"); } finally { RxJavaCommonPlugins.reset(); } } @Test public void onSubscribeAndDisposeCrashes() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, true, false); SafeSubscriber<Object> so = cd.toSafe(); so.onSubscribe(cd); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, TestException.class, "onSubscribe()"); TestCommonHelper.assertError(ce, 1, TestException.class, "cancel()"); } finally { RxJavaCommonPlugins.reset(); } }
SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { public SerializedSubscriber(Subscriber<? super T> actual) { this(actual, false); } SerializedSubscriber(Subscriber<? super T> actual); SerializedSubscriber(Subscriber<? super T> actual, boolean delayError); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void request(long n); @Override void cancel(); }
@Test public void testMultiThreadedBasic() { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three"); Flowable<String> w = Flowable.unsafeCreate(onSubscribe); BusySubscriber busySubscriber = new BusySubscriber(); Subscriber<String> aw = serializedSubscriber(busySubscriber); w.subscribe(aw); onSubscribe.waitToFinish(); assertEquals(3, busySubscriber.onNextCount.get()); assertFalse(busySubscriber.onError); assertTrue(busySubscriber.onComplete); assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); assertEquals(1, busySubscriber.maxConcurrentThreads.get()); } @Test(timeout = 1000) public void testMultiThreadedWithNPE() throws InterruptedException { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null); Flowable<String> w = Flowable.unsafeCreate(onSubscribe); BusySubscriber busySubscriber = new BusySubscriber(); Subscriber<String> aw = serializedSubscriber(busySubscriber); w.subscribe(aw); onSubscribe.waitToFinish(); busySubscriber.terminalEvent.await(); System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + " Subscriber maxConcurrentThreads: " + busySubscriber.maxConcurrentThreads.get()); assertTrue(busySubscriber.onNextCount.get() < 4); assertTrue(busySubscriber.onError); assertFalse(busySubscriber.onComplete); assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); assertEquals(1, busySubscriber.maxConcurrentThreads.get()); } @Test public void testMultiThreadedWithNPEinMiddle() { int n = 10; for (int i = 0; i < n; i++) { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine"); Flowable<String> w = Flowable.unsafeCreate(onSubscribe); BusySubscriber busySubscriber = new BusySubscriber(); Subscriber<String> aw = serializedSubscriber(busySubscriber); w.subscribe(aw); onSubscribe.waitToFinish(); System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + " Subscriber maxConcurrentThreads: " + busySubscriber.maxConcurrentThreads.get()); assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); assertEquals(1, busySubscriber.maxConcurrentThreads.get()); System.out.println("onNext count: " + busySubscriber.onNextCount.get()); assertFalse(busySubscriber.onComplete); assertTrue(busySubscriber.onError); assertTrue(busySubscriber.onNextCount.get() < 9); } } @Test public void runOutOfOrderConcurrencyTest() { ExecutorService tp = Executors.newFixedThreadPool(20); try { TestConcurrencySubscriber tw = new TestConcurrencySubscriber(); Subscriber<String> w = serializedSubscriber(new SafeSubscriber<String>(tw)); Future<?> f1 = tp.submit(new OnNextThread(w, 12000)); Future<?> f2 = tp.submit(new OnNextThread(w, 5000)); Future<?> f3 = tp.submit(new OnNextThread(w, 75000)); Future<?> f4 = tp.submit(new OnNextThread(w, 13500)); Future<?> f5 = tp.submit(new OnNextThread(w, 22000)); Future<?> f6 = tp.submit(new OnNextThread(w, 15000)); Future<?> f7 = tp.submit(new OnNextThread(w, 7500)); Future<?> f8 = tp.submit(new OnNextThread(w, 23500)); Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f1, f2, f3, f4)); try { Thread.sleep(1); } catch (InterruptedException e) { } Future<?> f11 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f4, f6, f7)); Future<?> f12 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f4, f6, f7)); Future<?> f13 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f4, f6, f7)); Future<?> f14 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f4, f6, f7)); Future<?> f15 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onError, f1, f2, f3, f4)); Future<?> f16 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onError, f1, f2, f3, f4)); Future<?> f17 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onError, f1, f2, f3, f4)); Future<?> f18 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onError, f1, f2, f3, f4)); waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10, f11, f12, f13, f14, f15, f16, f17, f18); @SuppressWarnings("unused") int numNextEvents = tw.assertEvents(null); } catch (Throwable e) { fail("Concurrency test failed: " + e.getMessage()); e.printStackTrace(); } finally { tp.shutdown(); try { tp.awaitTermination(5000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { e.printStackTrace(); } } }
SerializedSubscriber implements RelaxedSubscriber<T>, Subscription { @Override public void onNext(T t) { if (done) { return; } if (t == null) { subscription.cancel(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized (this) { if (done) { return; } if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(QUEUE_LINK_SIZE); queue = q; } q.add(NotificationLite.next(t)); return; } emitting = true; } actual.onNext(t); emitLoop(); } 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(); }
@Test @Ignore("Null values not permitted") public void testSerializeNull() { final AtomicReference<Subscriber<Integer>> serial = new AtomicReference<Subscriber<Integer>>(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { if (t != null && t == 0) { serial.get().onNext(null); } super.onNext(t); } }; SerializedSubscriber<Integer> sobs = new SerializedSubscriber<Integer>(to); serial.set(sobs); sobs.onNext(0); to.assertValues(0, null); } @Test @Ignore("Null values no longer permitted") public void testSerializeDrainPhaseThrows() { final AtomicReference<Subscriber<Integer>> serial = new AtomicReference<Subscriber<Integer>>(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { if (t != null && t == 0) { serial.get().onNext(null); } else if (t == null) { throw new TestException(); } super.onNext(t); } }; SerializedSubscriber<Integer> sobs = new SerializedSubscriber<Integer>(to); serial.set(sobs); sobs.onNext(0); to.assertError(TestException.class); to.assertNotComplete(); }
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(); }
@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()); } }
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(); }
@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(); } }
RxJavaFlowablePlugins { public static void lockdown() { lockdown = true; } private RxJavaFlowablePlugins(); static void lockdown(); static boolean isLockdown(); static void reset(); @SuppressWarnings("rawtypes") @Nullable static Function<? super Flowable, ? extends Flowable> getOnFlowableAssembly(); @SuppressWarnings("rawtypes") @Nullable static Function<? super ConnectableFlowable, ? extends ConnectableFlowable> getOnConnectableFlowableAssembly(); @Nullable @SuppressWarnings("rawtypes") static BiFunction<? super Flowable, ? super Subscriber, ? extends Subscriber> getOnFlowableSubscribe(); @SuppressWarnings("rawtypes") static void setOnFlowableAssembly(@Nullable Function<? super Flowable, ? extends Flowable> onFlowableAssembly); @SuppressWarnings("rawtypes") static void setOnConnectableFlowableAssembly(@Nullable Function<? super ConnectableFlowable, ? extends ConnectableFlowable> onConnectableFlowableAssembly); @SuppressWarnings("rawtypes") static void setOnFlowableSubscribe(@Nullable BiFunction<? super Flowable, ? super Subscriber, ? extends Subscriber> onFlowableSubscribe); @SuppressWarnings({ "rawtypes", "unchecked" }) @NonNull static Subscriber<? super T> onSubscribe(@NonNull Flowable<T> source, @NonNull Subscriber<? super T> subscriber); @SuppressWarnings({ "rawtypes", "unchecked" }) @NonNull static Flowable<T> onAssembly(@NonNull Flowable<T> source); @SuppressWarnings({ "rawtypes", "unchecked" }) @NonNull static ConnectableFlowable<T> onAssembly(@NonNull ConnectableFlowable<T> source); @SuppressWarnings("rawtypes") static void setOnParallelAssembly(@Nullable Function<? super ParallelFlowable, ? extends ParallelFlowable> handler); @SuppressWarnings("rawtypes") @Nullable static Function<? super ParallelFlowable, ? extends ParallelFlowable> getOnParallelAssembly(); @SuppressWarnings({ "rawtypes", "unchecked" }) @NonNull static ParallelFlowable<T> onAssembly(@NonNull ParallelFlowable<T> source); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); }
@SuppressWarnings({ "rawtypes" }) @Test public void lockdown() throws Exception { RxJavaFlowablePlugins.reset(); RxJavaFlowablePlugins.lockdown(); try { assertTrue(RxJavaFlowablePlugins.isLockdown()); Consumer a1 = Functions.emptyConsumer(); Callable f0 = new Callable() { @Override public Object call() { return null; } }; Function f1 = Functions.identity(); BiFunction f2 = new BiFunction() { @Override public Object apply(Object t1, Object t2) { return t2; } }; BooleanSupplier bs = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return true; } }; for (Method m : RxJavaFlowablePlugins.class.getMethods()) { if (m.getName().startsWith("set")) { Method getter; Class<?> paramType = m.getParameterTypes()[0]; if (paramType == Boolean.TYPE) { getter = RxJavaFlowablePlugins.class.getMethod("is" + m.getName().substring(3)); } else { getter = RxJavaFlowablePlugins.class.getMethod("get" + m.getName().substring(3)); } Object before = getter.invoke(null); try { if (paramType.isAssignableFrom(Boolean.TYPE)) { m.invoke(null, true); } else if (paramType.isAssignableFrom(Callable.class)) { m.invoke(null, f0); } else if (paramType.isAssignableFrom(Function.class)) { m.invoke(null, f1); } else if (paramType.isAssignableFrom(Consumer.class)) { m.invoke(null, a1); } else if (paramType.isAssignableFrom(BooleanSupplier.class)) { m.invoke(null, bs); } else { m.invoke(null, f2); } fail("Should have thrown InvocationTargetException(IllegalStateException)"); } catch (InvocationTargetException ex) { if (ex.getCause() instanceof IllegalStateException) { assertEquals("Plugins can't be changed anymore",ex.getCause().getMessage()); } else { fail("Should have thrown InvocationTargetException(IllegalStateException)"); } } Object after = getter.invoke(null); if (paramType.isPrimitive()) { assertEquals(m.toString(), before, after); } else { assertSame(m.toString(), before, after); } } } } finally { RxJavaFlowablePlugins.unlock(); RxJavaFlowablePlugins.reset(); assertFalse(RxJavaFlowablePlugins.isLockdown()); } }
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(); }
@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()); }
ReplayProcessor extends FlowableProcessor<T> { @CheckReturnValue public static <T> ReplayProcessor<T> create() { return new ReplayProcessor<T>(new UnboundedReplayBuffer<T>(16)); } @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(); }
@Test public void createInvalidCapacity() { try { ReplayProcessor.create(-99); fail("Didn't throw IllegalArgumentException"); } catch (IllegalArgumentException ex) { assertEquals("capacityHint > 0 required but it was -99", ex.getMessage()); } } @Test public void subscribeCancelRace() { for (int i = 0; i < 500; i++) { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); final ReplayProcessor<Integer> rp = ReplayProcessor.create(); Runnable r1 = new Runnable() { @Override public void run() { rp.subscribe(ts); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } } @Test public void subscribeRace() { for (int i = 0; i < 500; i++) { final ReplayProcessor<Integer> rp = ReplayProcessor.create(); Runnable r1 = new Runnable() { @Override public void run() { rp.test(); } }; TestCommonHelper.race(r1, r1, Schedulers.single()); } }
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(); }
@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()); } }
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(); }
@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()); } }
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(); }
@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()); }
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); }
@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()); } }
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(); }
@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()); } }
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(); }
@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()); } }
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(); }
@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); }
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(); }
@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)); } }
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(); }
@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(); } }
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(); }
@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(); } } }
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(); }
@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(); } }
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(); }
@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()); }
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(); }
@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()); } }
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(); }
@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); }
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(); }
@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()); } }
UnicastProcessor extends FlowableProcessor<T> { @CheckReturnValue public static <T> UnicastProcessor<T> create() { return new UnicastProcessor<T>(bufferSize()); } UnicastProcessor(int capacityHint); UnicastProcessor(int capacityHint, Runnable onTerminate); UnicastProcessor(int capacityHint, Runnable onTerminate, boolean delayError); @CheckReturnValue static UnicastProcessor<T> create(); @CheckReturnValue static UnicastProcessor<T> create(int capacityHint); @CheckReturnValue static UnicastProcessor<T> create(boolean delayError); @CheckReturnValue static UnicastProcessor<T> create(int capacityHint, Runnable onCancelled); @CheckReturnValue static UnicastProcessor<T> create(int capacityHint, Runnable onCancelled, boolean delayError); @Override void onSubscribe(Subscription s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasSubscribers(); @Override Throwable getThrowable(); @Override boolean hasComplete(); @Override boolean hasThrowable(); }
@Test public void onTerminateCalledWhenCanceled() { final AtomicBoolean didRunOnTerminate = new AtomicBoolean(); UnicastProcessor<Integer> us = UnicastProcessor.create(Flowable.bufferSize(), new Runnable() { @Override public void run() { didRunOnTerminate.set(true); } }); final Disposable subscribe = us.subscribe(); assertEquals(false, didRunOnTerminate.get()); subscribe.dispose(); assertEquals(true, didRunOnTerminate.get()); } @Test(expected = NullPointerException.class) public void nullOnTerminate() { UnicastProcessor.create(5, null); } @Test(expected = IllegalArgumentException.class) public void negativeCapacityHint() { UnicastProcessor.create(-1); } @Test(expected = IllegalArgumentException.class) public void zeroCapacityHint() { UnicastProcessor.create(0); } @Test public void rejectSyncFusion() { UnicastProcessor<Object> p = UnicastProcessor.create(); TestSubscriber<Object> ts = SubscriberFusion.newTest(FusedQueueSubscription.SYNC); p.subscribe(ts); SubscriberFusion.assertFusion(ts, FusedQueueSubscription.NONE); } @Test public void cancelOnArrival() { UnicastProcessor.create() .test(0L, true) .assertEmpty(); }
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(); }
@Test public void FusedQueueSubscriptionSyncRejected() { DeferredScalarSubscription<Integer> ds = new DeferredScalarSubscription<Integer>(new TestSubscriber<Integer>()); assertEquals(FusedQueueSubscription.NONE, ds.requestFusion(FusedQueueSubscription.SYNC)); }
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(); }
@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); }
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(); }
@Test public void cancel() { DeferredScalarSubscription<Integer> ds = new DeferredScalarSubscription<Integer>(new TestSubscriber<Integer>()); assertTrue(ds.tryCancel()); assertFalse(ds.tryCancel()); }
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(); }
@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()); } }
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(); }
@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()); } }
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); }
@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(); } }
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); }
@Test public void initialCancel() { FullArbiter.INITIAL.cancel(); }
FullArbiter extends FullArbiterPad2 implements Subscription { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Subscriber<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if (o == REQUEST) { long mr = missedRequested.getAndSet(0L); if (mr != 0L) { requested = BackpressureHelper.addCap(requested, mr); s.request(mr); } } else if (o == s) { if (NotificationLite.isSubscription(v)) { Subscription next = NotificationLite.getSubscription(v); if (!cancelled) { s = next; long r = requested; if (r != 0L) { next.request(r); } } else { next.cancel(); } } else if (NotificationLite.isError(v)) { q.clear(); dispose(); Throwable ex = NotificationLite.getError(v); if (!cancelled) { cancelled = true; a.onError(ex); } else { RxJavaCommonPlugins.onError(ex); } } else if (NotificationLite.isComplete(v)) { q.clear(); dispose(); if (!cancelled) { cancelled = true; a.onComplete(); } } else { long r = requested; if (r != 0) { a.onNext(NotificationLite.<T>getValue(v)); requested = r - 1; } } } } missed = wip.addAndGet(-missed); if (missed == 0) { break; } } } 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); }
@Test public void offerDifferentSubscription() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); FullArbiter<Integer> fa = new FullArbiter<Integer>(ts, null, 128); BooleanSubscription bs = new BooleanSubscription(); fa.queue.offer(bs, NotificationLite.next(1)); fa.drain(); ts.assertNoValues(); }
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); }
@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(); } }
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); }
@Test public void testSetResource() { AsyncSubscription as = new AsyncSubscription(); Disposable r = mock(Disposable.class); assertTrue(as.setResource(r)); as.cancel(); verify(r).dispose(); }
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); }
@Test public void testReplaceResource() { AsyncSubscription as = new AsyncSubscription(); Disposable r = mock(Disposable.class); assertTrue(as.replaceResource(r)); as.cancel(); verify(r).dispose(); }
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(); }
@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(); } }
SubscriptionArbiter extends AtomicInteger implements Subscription { final void drainLoop() { int missed = 1; long requestAmount = 0L; Subscription requestTarget = null; for (; ; ) { Subscription ms = missedSubscription.get(); if (ms != null) { ms = missedSubscription.getAndSet(null); } long mr = missedRequested.get(); if (mr != 0L) { mr = missedRequested.getAndSet(0L); } long mp = missedProduced.get(); if (mp != 0L) { mp = missedProduced.getAndSet(0L); } Subscription a = actual; if (cancelled) { if (a != null) { a.cancel(); actual = null; } if (ms != null) { ms.cancel(); } } else { long r = requested; if (r != Long.MAX_VALUE) { long u = BackpressureHelper.addCap(r, mr); if (u != Long.MAX_VALUE) { long v = u - mp; if (v < 0L) { SubscriptionHelper.reportMoreProduced(v); v = 0; } r = v; } else { r = u; } requested = r; } if (ms != null) { if (a != null) { a.cancel(); } actual = ms; if (r != 0L) { requestAmount = BackpressureHelper.addCap(requestAmount, r); requestTarget = ms; } } else if (a != null && mr != 0L) { requestAmount = BackpressureHelper.addCap(requestAmount, mr); requestTarget = a; } } missed = addAndGet(-missed); if (missed == 0) { if (requestAmount != 0L) { requestTarget.request(requestAmount); } return; } } } 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(); }
@Test public void drainUnbounded() { SubscriptionArbiter sa = new SubscriptionArbiter(); sa.getAndIncrement(); sa.requested = Long.MAX_VALUE; sa.drainLoop(); } @Test public void drainMissedRequested() { SubscriptionArbiter sa = new SubscriptionArbiter(); sa.getAndIncrement(); sa.requested = 0; sa.missedRequested.set(1); sa.drainLoop(); assertEquals(1, sa.requested); } @Test public void drainMissedRequestedProduced() { SubscriptionArbiter sa = new SubscriptionArbiter(); sa.getAndIncrement(); sa.requested = 0; sa.missedRequested.set(Long.MAX_VALUE); sa.missedProduced.set(1); sa.drainLoop(); assertEquals(Long.MAX_VALUE, sa.requested); } @Test public void drainMissedRequestedMoreProduced() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { SubscriptionArbiter sa = new SubscriptionArbiter(); sa.getAndIncrement(); sa.requested = 0; sa.missedRequested.set(1); sa.missedProduced.set(2); sa.drainLoop(); assertEquals(0, sa.requested); TestCommonHelper.assertError(errors, 0, IllegalStateException.class, "More produced than requested: -1"); } finally { RxJavaCommonPlugins.reset(); } } @Test public void missedSubscriptionNoPrior() { SubscriptionArbiter sa = new SubscriptionArbiter(); sa.getAndIncrement(); BooleanSubscription bs1 = new BooleanSubscription(); sa.missedSubscription.set(bs1); sa.drainLoop(); assertSame(bs1, sa.actual); }
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(); }
@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()); } }
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(); }
@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()); }
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(); }
@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); }
DeferredScalarSubscriber extends DeferredScalarSubscription<R> implements RelaxedSubscriber<T> { @Override public void onComplete() { if (hasValue) { complete(value); } else { actual.onComplete(); } } DeferredScalarSubscriber(Subscriber<? super R> actual); @Override void onSubscribe(Subscription s); @Override void onError(Throwable t); @Override void onComplete(); @Override void cancel(); }
@Test public void completeFirst() { TestSubscriber<Integer> ts = TestSubscriber.create(0L); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ds.onNext(1); ts.assertNoValues(); ds.onComplete(); ts.assertNoValues(); ts.request(1); ts.assertValues(1); ts.assertNoErrors(); ts.assertComplete(); } @Test public void requestFirst() { TestSubscriber<Integer> ts = TestSubscriber.create(1); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ds.onNext(1); ts.assertNoValues(); ds.onComplete(); ts.assertValues(1); ts.assertNoErrors(); ts.assertComplete(); } @Test public void empty() { TestSubscriber<Integer> ts = TestSubscriber.create(0L); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ts.assertNoValues(); ds.onComplete(); ts.assertNoValues(); ts.assertNoErrors(); ts.assertComplete(); } @Test public void doubleComplete() { TestSubscriber<Integer> ts = TestSubscriber.create(0); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ds.onNext(1); ts.request(1); ds.onComplete(); ds.onComplete(); ts.assertValue(1); ts.assertNoErrors(); ts.assertComplete(); } @Test public void doubleComplete2() { TestSubscriber<Integer> ts = TestSubscriber.create(0); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ds.onNext(1); ds.onComplete(); ds.onComplete(); ts.request(1); ts.assertValue(1); ts.assertNoErrors(); ts.assertComplete(); } @Test public void doubleRequest() { TestSubscriber<Integer> ts = TestSubscriber.create(0); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ds.onNext(1); ts.request(1); ts.request(1); ds.onComplete(); ts.assertValue(1); ts.assertNoErrors(); ts.assertComplete(); } @Test public void emissionRequestRace() { Worker w = Schedulers.computation().createWorker(); try { for (int i = 0; i < 10000; i++) { final TestSubscriber<Integer> ts = TestSubscriber.create(0L); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ds.onNext(1); final AtomicInteger ready = new AtomicInteger(2); w.schedule(new Runnable() { @Override public void run() { ready.decrementAndGet(); while (ready.get() != 0) { } ts.request(1); } }); ready.decrementAndGet(); while (ready.get() != 0) { } ds.onComplete(); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); ts.assertValues(1); ts.assertNoErrors(); ts.assertComplete(); } } finally { w.dispose(); } } @Test public void emissionRequestRace2() { Worker w = Schedulers.io().createWorker(); Worker w2 = Schedulers.io().createWorker(); int m = 10000; if (Runtime.getRuntime().availableProcessors() < 3) { m = 1000; } try { for (int i = 0; i < m; i++) { final TestSubscriber<Integer> ts = TestSubscriber.create(0L); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.setupDownstream(); ds.onNext(1); final AtomicInteger ready = new AtomicInteger(3); w.schedule(new Runnable() { @Override public void run() { ready.decrementAndGet(); while (ready.get() != 0) { } ts.request(1); } }); w2.schedule(new Runnable() { @Override public void run() { ready.decrementAndGet(); while (ready.get() != 0) { } ts.request(1); } }); ready.decrementAndGet(); while (ready.get() != 0) { } ds.onComplete(); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); ts.assertValues(1); ts.assertNoErrors(); ts.assertComplete(); } } finally { w.dispose(); w2.dispose(); } }
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(); }
@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(); }
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(); }
@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)); }
StrictSubscriber extends AtomicInteger implements RelaxedSubscriber<T>, Subscription { @Override public void request(long n) { if (n <= 0) { cancel(); onError(new IllegalArgumentException("§3.9 violated: positive request amount required but it was " + n)); } else { SubscriptionHelper.deferredRequest(s, requested, n); } } 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(); }
@Test public void deferredRequest() { final List<Object> list = new ArrayList<Object>(); Subscriber<Object> sub = new Subscriber<Object>() { @Override public void onSubscribe(Subscription s) { s.request(5); list.add(0); } @Override public void onNext(Object t) { list.add(t); } @Override public void onError(Throwable t) { list.add(t); } @Override public void onComplete() { list.add("Done"); } }; Flowable.range(1, 5).subscribe(sub); assertEquals(Arrays.<Object>asList(0, 1, 2, 3, 4, 5, "Done"), list); } @Test public void requestZero() { final List<Object> list = new ArrayList<Object>(); Subscriber<Object> sub = new Subscriber<Object>() { @Override public void onSubscribe(Subscription s) { s.request(0); } @Override public void onNext(Object t) { list.add(t); } @Override public void onError(Throwable t) { list.add(t); } @Override public void onComplete() { list.add("Done"); } }; Flowable.range(1, 5).subscribe(sub); assertTrue(list.toString(), list.get(0) instanceof IllegalArgumentException); assertTrue(list.toString(), list.get(0).toString().contains("3.9")); } @Test public void requestNegative() { final List<Object> list = new ArrayList<Object>(); Subscriber<Object> sub = new Subscriber<Object>() { @Override public void onSubscribe(Subscription s) { s.request(-99); } @Override public void onNext(Object t) { list.add(t); } @Override public void onError(Throwable t) { list.add(t); } @Override public void onComplete() { list.add("Done"); } }; Flowable.range(1, 5).subscribe(sub); assertTrue(list.toString(), list.get(0) instanceof IllegalArgumentException); assertTrue(list.toString(), list.get(0).toString().contains("3.9")); }
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(); }
@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")); }
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); }
@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()); } }
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); }
@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(); } }
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); }
@Test public void onNext() throws Exception { fs.onNext(1); fs.onComplete(); assertEquals(1, fs.get(5, TimeUnit.MILLISECONDS).intValue()); }
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); }
@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(); } }
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; }
@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()); }
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; }
@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()); }
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); }
@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()); }
FlowableReplay extends ConnectableFlowable<T> implements HasUpstreamPublisher<T>, Disposable { public static <T> ConnectableFlowable<T> create(Flowable<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferTask<T>(bufferSize)); } 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); }
@Test public void testReplaySelector() { final Function<Integer, Integer> dbl = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { return t1 * 2; } }; Function<Flowable<Integer>, Flowable<Integer>> selector = new Function<Flowable<Integer>, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Flowable<Integer> t1) { return t1.map(dbl); } }; PublishProcessor<Integer> source = PublishProcessor.create(); Flowable<Integer> co = source.replay(selector); { Subscriber<Object> observer1 = TestHelper.mockSubscriber(); InOrder inOrder = inOrder(observer1); co.subscribe(observer1); source.onNext(1); source.onNext(2); source.onNext(3); inOrder.verify(observer1, times(1)).onNext(2); inOrder.verify(observer1, times(1)).onNext(4); inOrder.verify(observer1, times(1)).onNext(6); source.onNext(4); source.onComplete(); inOrder.verify(observer1, times(1)).onNext(8); inOrder.verify(observer1, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); verify(observer1, never()).onError(any(Throwable.class)); } { Subscriber<Object> observer1 = TestHelper.mockSubscriber(); InOrder inOrder = inOrder(observer1); co.subscribe(observer1); inOrder.verify(observer1, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); verify(observer1, never()).onError(any(Throwable.class)); } } @Test public void testBufferedReplaySelector() { final Function<Integer, Integer> dbl = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { return t1 * 2; } }; Function<Flowable<Integer>, Flowable<Integer>> selector = new Function<Flowable<Integer>, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Flowable<Integer> t1) { return t1.map(dbl); } }; PublishProcessor<Integer> source = PublishProcessor.create(); Flowable<Integer> co = source.replay(selector, 3); { Subscriber<Object> observer1 = TestHelper.mockSubscriber(); InOrder inOrder = inOrder(observer1); co.subscribe(observer1); source.onNext(1); source.onNext(2); source.onNext(3); inOrder.verify(observer1, times(1)).onNext(2); inOrder.verify(observer1, times(1)).onNext(4); inOrder.verify(observer1, times(1)).onNext(6); source.onNext(4); source.onComplete(); inOrder.verify(observer1, times(1)).onNext(8); inOrder.verify(observer1, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); verify(observer1, never()).onError(any(Throwable.class)); } { Subscriber<Object> observer1 = TestHelper.mockSubscriber(); InOrder inOrder = inOrder(observer1); co.subscribe(observer1); inOrder.verify(observer1, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); verify(observer1, never()).onError(any(Throwable.class)); } } @Test public void testWindowedReplaySelector() { final Function<Integer, Integer> dbl = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { return t1 * 2; } }; Function<Flowable<Integer>, Flowable<Integer>> selector = new Function<Flowable<Integer>, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Flowable<Integer> t1) { return t1.map(dbl); } }; TestScheduler scheduler = new TestScheduler(); PublishProcessor<Integer> source = PublishProcessor.create(); Flowable<Integer> co = source.replay(selector, 100, TimeUnit.MILLISECONDS, scheduler); { Subscriber<Object> observer1 = TestHelper.mockSubscriber(); InOrder inOrder = inOrder(observer1); co.subscribe(observer1); source.onNext(1); scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); source.onNext(2); scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); source.onNext(3); scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); source.onComplete(); scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); inOrder.verify(observer1, times(1)).onNext(2); inOrder.verify(observer1, times(1)).onNext(4); inOrder.verify(observer1, times(1)).onNext(6); inOrder.verify(observer1, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); verify(observer1, never()).onError(any(Throwable.class)); } { Subscriber<Object> observer1 = TestHelper.mockSubscriber(); InOrder inOrder = inOrder(observer1); co.subscribe(observer1); inOrder.verify(observer1, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); verify(observer1, never()).onError(any(Throwable.class)); } } @Test public void cancelOnArrival2() { ConnectableFlowable<Integer> co = PublishProcessor.<Integer>create() .replay(Integer.MAX_VALUE); co.test(); co .autoConnect() .test(Long.MAX_VALUE, true) .assertEmpty(); } @Test public void subscribeOnNextRace() { for (int i = 0; i < 500; i++) { final PublishProcessor<Integer> ps = PublishProcessor.create(); final ConnectableFlowable<Integer> co = ps.replay(); final TestSubscriber<Integer> to1 = new TestSubscriber<Integer>(); Runnable r1 = new Runnable() { @Override public void run() { co.subscribe(to1); } }; Runnable r2 = new Runnable() { @Override public void run() { for (int j = 0; j < 1000; j++) { ps.onNext(j); } } }; TestCommonHelper.race(r1, r2); } } @Test public void reentrantOnNext() { final PublishProcessor<Integer> ps = PublishProcessor.create(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { if (t == 1) { ps.onNext(2); ps.onComplete(); } super.onNext(t); } }; ps.replay().autoConnect().subscribe(to); ps.onNext(1); to.assertResult(1, 2); } @Test public void reentrantOnNextBound() { final PublishProcessor<Integer> ps = PublishProcessor.create(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { if (t == 1) { ps.onNext(2); ps.onComplete(); } super.onNext(t); } }; ps.replay(10).autoConnect().subscribe(to); ps.onNext(1); to.assertResult(1, 2); } @Test public void reentrantOnNextCancel() { final PublishProcessor<Integer> ps = PublishProcessor.create(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { if (t == 1) { ps.onNext(2); cancel(); } super.onNext(t); } }; ps.replay().autoConnect().subscribe(to); ps.onNext(1); to.assertValues(1); } @Test public void reentrantOnNextCancelBounded() { final PublishProcessor<Integer> ps = PublishProcessor.create(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { if (t == 1) { ps.onNext(2); cancel(); } super.onNext(t); } }; ps.replay(10).autoConnect().subscribe(to); ps.onNext(1); to.assertValues(1); }
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(); }
@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()); } }
FlowableReplay extends ConnectableFlowable<T> implements HasUpstreamPublisher<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplaySubscriber<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf; try { buf = bufferFactory.call(); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOrThrow(ex); } ReplaySubscriber<T> u = new ReplaySubscriber<T>(buf); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.shouldConnect.get() && ps.shouldConnect.compareAndSet(false, true); break; } try { connection.accept(ps); } catch (Throwable ex) { if (doConnect) { ps.shouldConnect.compareAndSet(true, false); } Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOrThrow(ex); } if (doConnect) { source.subscribe(ps); } } 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); }
@SuppressWarnings("unchecked") @Test public void testIssue2191_UnsubscribeSource() throws Exception { Consumer<Integer> sourceNext = mock(Consumer.class); Action sourceCompleted = mock(Action.class); Action sourceUnsubscribed = mock(Action.class); Subscriber<Integer> spiedSubscriberBeforeConnect = TestHelper.mockSubscriber(); Subscriber<Integer> spiedSubscriberAfterConnect = TestHelper.mockSubscriber(); Flowable<Integer> source = Flowable.just(1,2); ConnectableFlowable<Integer> replay = source .doOnNext(sourceNext) .doOnCancel(sourceUnsubscribed) .doOnComplete(sourceCompleted) .replay(); replay.subscribe(spiedSubscriberBeforeConnect); replay.subscribe(spiedSubscriberBeforeConnect); replay.connect(); replay.subscribe(spiedSubscriberAfterConnect); replay.subscribe(spiedSubscriberAfterConnect); verify(spiedSubscriberBeforeConnect, times(2)).onSubscribe((Subscription)any()); verify(spiedSubscriberAfterConnect, times(2)).onSubscribe((Subscription)any()); verify(sourceNext, times(1)).accept(1); verify(sourceNext, times(1)).accept(2); verify(sourceCompleted, times(1)).run(); verifyObserverMock(spiedSubscriberBeforeConnect, 2, 4); verifyObserverMock(spiedSubscriberAfterConnect, 2, 4); verify(sourceUnsubscribed, never()).run(); verifyNoMoreInteractions(sourceNext); verifyNoMoreInteractions(sourceCompleted); verifyNoMoreInteractions(sourceUnsubscribed); verifyNoMoreInteractions(spiedSubscriberBeforeConnect); verifyNoMoreInteractions(spiedSubscriberAfterConnect); } @Test public void testBackpressure() { final AtomicLong requested = new AtomicLong(); Flowable<Integer> source = Flowable.range(1, 1000) .doOnRequest(new LongConsumer() { @Override public void accept(long t) { requested.addAndGet(t); } }); ConnectableFlowable<Integer> co = source.replay(); TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(10L); TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>(90L); co.subscribe(ts1); co.subscribe(ts2); ts2.request(10); co.connect(); ts1.assertValueCount(10); ts1.assertNotTerminated(); ts2.assertValueCount(100); ts2.assertNotTerminated(); Assert.assertEquals(100, requested.get()); } @Test public void testBackpressureBounded() { final AtomicLong requested = new AtomicLong(); Flowable<Integer> source = Flowable.range(1, 1000) .doOnRequest(new LongConsumer() { @Override public void accept(long t) { requested.addAndGet(t); } }); ConnectableFlowable<Integer> co = source.replay(50); TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(10L); TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>(90L); co.subscribe(ts1); co.subscribe(ts2); ts2.request(10); co.connect(); ts1.assertValueCount(10); ts1.assertNotTerminated(); ts2.assertValueCount(100); ts2.assertNotTerminated(); Assert.assertEquals(100, requested.get()); } @Test public void connectRace() { for (int i = 0; i < 500; i++) { final ConnectableFlowable<Integer> co = Flowable.range(1, 3).replay(); Runnable r = new Runnable() { @Override public void run() { co.connect(); } }; TestCommonHelper.race(r, r); } } @Test public void connectConsumerThrows() { ConnectableFlowable<Integer> co = Flowable.range(1, 2) .replay(); try { co.connect(new Consumer<Disposable>() { @Override public void accept(Disposable t) throws Exception { throw new TestException(); } }); fail("Should have thrown"); } catch (TestException ex) { } co.test().assertEmpty().cancel(); co.connect(); co.test().assertResult(1, 2); }
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); }
@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(); }
FlowableReplay extends ConnectableFlowable<T> implements HasUpstreamPublisher<T>, Disposable { public static <T> ConnectableFlowable<T> observeOn(final ConnectableFlowable<T> co, final Scheduler scheduler) { final Flowable<T> observable = co.observeOn(scheduler); return RxJavaFlowablePlugins.onAssembly(new ConnectableFlowableReplay<T>(co, observable)); } 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); }
@Test public void testAsync() { Flowable<Integer> source = Flowable.range(1, 10000); for (int i = 0; i < 100; i++) { TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(); Flowable<Integer> cached = source.replay().autoConnect(); cached.observeOn(Schedulers.computation()).subscribe(ts1); ts1.awaitTerminalEvent(2, TimeUnit.SECONDS); ts1.assertNoErrors(); ts1.assertTerminated(); assertEquals(10000, ts1.values().size()); TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>(); cached.observeOn(Schedulers.computation()).subscribe(ts2); ts2.awaitTerminalEvent(2, TimeUnit.SECONDS); ts2.assertNoErrors(); ts2.assertTerminated(); assertEquals(10000, ts2.values().size()); } } @Test public void testAsyncComeAndGo() { Flowable<Long> source = Flowable.interval(1, 1, TimeUnit.MILLISECONDS) .take(1000) .subscribeOn(Schedulers.io()); Flowable<Long> cached = source.replay().autoConnect(); Flowable<Long> output = cached.observeOn(Schedulers.computation(), false, 1024); List<TestSubscriber<Long>> list = new ArrayList<TestSubscriber<Long>>(100); for (int i = 0; i < 100; i++) { TestSubscriber<Long> ts = new TestSubscriber<Long>(); list.add(ts); output.skip(i * 10).take(10).subscribe(ts); } List<Long> expected = new ArrayList<Long>(); for (int i = 0; i < 10; i++) { expected.add((long)(i - 10)); } int j = 0; for (TestSubscriber<Long> ts : list) { ts.awaitTerminalEvent(3, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertTerminated(); for (int i = j * 10; i < j * 10 + 10; i++) { expected.set(i - j * 10, (long)i); } ts.assertValueSequence(expected); j++; } } @Test public void testNoMissingBackpressureException() { final int m = 4 * 1000 * 1000; Flowable<Integer> firehose = Flowable.unsafeCreate(new Publisher<Integer>() { @Override public void subscribe(Subscriber<? super Integer> t) { t.onSubscribe(new BooleanSubscription()); for (int i = 0; i < m; i++) { t.onNext(i); } t.onComplete(); } }); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); firehose.replay().autoConnect().observeOn(Schedulers.computation()).takeLast(100).subscribe(ts); ts.awaitTerminalEvent(3, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertTerminated(); assertEquals(100, ts.values().size()); }
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); }
@Test public void source() { Flowable<Integer> source = Flowable.range(1, 3); assertSame(source, (((HasUpstreamPublisher<?>)source.replay())).source()); }
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(); }
@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()); } }
BlockingFlowableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextSubscriber<T> nextSubscriber = new NextSubscriber<T>(); return new NextIterator<T>(source, nextSubscriber); } BlockingFlowableNext(Publisher<? extends T> source); @Override Iterator<T> iterator(); }
@Test public void testNext() { FlowableProcessor<String> obs = PublishProcessor.create(); Iterator<String> it = obs.blockingNext().iterator(); fireOnNextInNewThread(obs, "one"); assertTrue(it.hasNext()); assertEquals("one", it.next()); fireOnNextInNewThread(obs, "two"); assertTrue(it.hasNext()); assertEquals("two", it.next()); fireOnNextInNewThread(obs, "three"); try { assertEquals("three", it.next()); } catch (NoSuchElementException e) { fail("Calling next() without hasNext() should wait for next fire"); } obs.onComplete(); assertFalse(it.hasNext()); try { it.next(); fail("At the end of an iterator should throw a NoSuchElementException"); } catch (NoSuchElementException e) { } assertFalse(it.hasNext()); try { it.next(); fail("At the end of an iterator should throw a NoSuchElementException"); } catch (NoSuchElementException e) { } } @Test public void testNextWithError() { FlowableProcessor<String> obs = PublishProcessor.create(); Iterator<String> it = obs.blockingNext().iterator(); fireOnNextInNewThread(obs, "one"); assertTrue(it.hasNext()); assertEquals("one", it.next()); fireOnErrorInNewThread(obs); try { it.hasNext(); fail("Expected an TestException"); } catch (TestException e) { } assertErrorAfterObservableFail(it); } @Test public void testNextWithEmpty() { Flowable<String> obs = Flowable.<String> empty().observeOn(Schedulers.newThread()); Iterator<String> it = obs.blockingNext().iterator(); assertFalse(it.hasNext()); try { it.next(); fail("At the end of an iterator should throw a NoSuchElementException"); } catch (NoSuchElementException e) { } assertFalse(it.hasNext()); try { it.next(); fail("At the end of an iterator should throw a NoSuchElementException"); } catch (NoSuchElementException e) { } } @Test public void testOnError() throws Throwable { FlowableProcessor<String> obs = PublishProcessor.create(); Iterator<String> it = obs.blockingNext().iterator(); obs.onError(new TestException()); try { it.hasNext(); fail("Expected an TestException"); } catch (TestException e) { } assertErrorAfterObservableFail(it); } @Test public void testOnErrorInNewThread() { FlowableProcessor<String> obs = PublishProcessor.create(); Iterator<String> it = obs.blockingNext().iterator(); fireOnErrorInNewThread(obs); try { it.hasNext(); fail("Expected an TestException"); } catch (TestException e) { } assertErrorAfterObservableFail(it); } @Test public void testNextWithOnlyUsingNextMethod() { FlowableProcessor<String> obs = PublishProcessor.create(); Iterator<String> it = obs.blockingNext().iterator(); fireOnNextInNewThread(obs, "one"); assertEquals("one", it.next()); fireOnNextInNewThread(obs, "two"); assertEquals("two", it.next()); obs.onComplete(); try { it.next(); fail("At the end of an iterator should throw a NoSuchElementException"); } catch (NoSuchElementException e) { } } @Test public void testNextWithCallingHasNextMultipleTimes() { FlowableProcessor<String> obs = PublishProcessor.create(); Iterator<String> it = obs.blockingNext().iterator(); fireOnNextInNewThread(obs, "one"); assertTrue(it.hasNext()); assertTrue(it.hasNext()); assertTrue(it.hasNext()); assertTrue(it.hasNext()); assertEquals("one", it.next()); obs.onComplete(); try { it.next(); fail("At the end of an iterator should throw a NoSuchElementException"); } catch (NoSuchElementException e) { } } @Test public void testNoBufferingOrBlockingOfSequence() throws Throwable { int repeat = 0; for (;;) { final SerialDisposable task = new SerialDisposable(); try { final CountDownLatch finished = new CountDownLatch(1); final int COUNT = 30; final CountDownLatch timeHasPassed = new CountDownLatch(COUNT); final AtomicBoolean running = new AtomicBoolean(true); final AtomicInteger count = new AtomicInteger(0); final Flowable<Integer> obs = Flowable.unsafeCreate(new Publisher<Integer>() { @Override public void subscribe(final Subscriber<? super Integer> o) { o.onSubscribe(new BooleanSubscription()); task.replace(Schedulers.single().scheduleDirect(new Runnable() { @Override public void run() { try { while (running.get() && !task.isDisposed()) { o.onNext(count.incrementAndGet()); timeHasPassed.countDown(); } o.onComplete(); } catch (Throwable e) { o.onError(e); } finally { finished.countDown(); } } })); } }); Iterator<Integer> it = obs.blockingNext().iterator(); assertTrue(it.hasNext()); int a = it.next(); assertTrue(it.hasNext()); int b = it.next(); assertTrue("a and b should be different", a != b); timeHasPassed.await(8000, TimeUnit.MILLISECONDS); assertTrue(it.hasNext()); int c = it.next(); assertTrue("c should not just be the next in sequence", c != (b + 1)); assertTrue("expected that c [" + c + "] is higher than or equal to " + COUNT, c >= COUNT); assertTrue(it.hasNext()); int d = it.next(); assertTrue(d > c); running.set(false); finished.await(); assertFalse(it.hasNext()); System.out.println("a: " + a + " b: " + b + " c: " + c); break; } catch (AssertionError ex) { if (++repeat == 3) { throw ex; } Thread.sleep((int)(1000 * Math.pow(2, repeat - 1))); } finally { task.dispose(); } } } @Test public void testSingleSourceManyIterators() throws InterruptedException { Flowable<Long> o = Flowable.interval(250, TimeUnit.MILLISECONDS); PublishProcessor<Integer> terminal = PublishProcessor.create(); Flowable<Long> source = o.takeUntil(terminal); Iterable<Long> iter = source.blockingNext(); for (int j = 0; j < 3; j++) { BlockingFlowableNext.NextIterator<Long> it = (BlockingFlowableNext.NextIterator<Long>)iter.iterator(); for (long i = 0; i < 10; i++) { Assert.assertEquals(true, it.hasNext()); Assert.assertEquals(j + "th iteration next", Long.valueOf(i), it.next()); } terminal.onNext(1); } } @Test public void testSynchronousNext() { assertEquals(1, BehaviorProcessor.createDefault(1).take(1).blockingSingle().intValue()); assertEquals(2, BehaviorProcessor.createDefault(2).blockingIterable().iterator().next().intValue()); assertEquals(3, BehaviorProcessor.createDefault(3).blockingNext().iterator().next().intValue()); } @Test(expected = UnsupportedOperationException.class) public void remove() { Flowable.never().blockingNext().iterator().remove(); } @Test public void interrupt() { Iterator<Object> it = Flowable.never().blockingNext().iterator(); try { Thread.currentThread().interrupt(); it.next(); } catch (RuntimeException ex) { assertTrue(ex.toString(), ex.getCause() instanceof InterruptedException); } }
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; }
@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()); } }
BlockingFlowableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentSubscriber<T> mostRecentSubscriber = new MostRecentSubscriber<T>(initialValue); source.subscribe(mostRecentSubscriber); return mostRecentSubscriber.getIterable(); } BlockingFlowableMostRecent(Flowable<T> source, T initialValue); @Override Iterator<T> iterator(); }
@Test public void testMostRecentNull() { assertEquals(null, Flowable.<Void>never().blockingMostRecent(null).iterator().next()); } @Test public void testMostRecent() { FlowableProcessor<String> s = PublishProcessor.create(); Iterator<String> it = s.blockingMostRecent("default").iterator(); assertTrue(it.hasNext()); assertEquals("default", it.next()); assertEquals("default", it.next()); s.onNext("one"); assertTrue(it.hasNext()); assertEquals("one", it.next()); assertEquals("one", it.next()); s.onNext("two"); assertTrue(it.hasNext()); assertEquals("two", it.next()); assertEquals("two", it.next()); s.onComplete(); assertFalse(it.hasNext()); } @Test(expected = TestException.class) public void testMostRecentWithException() { FlowableProcessor<String> s = PublishProcessor.create(); Iterator<String> it = s.blockingMostRecent("default").iterator(); assertTrue(it.hasNext()); assertEquals("default", it.next()); assertEquals("default", it.next()); s.onError(new TestException()); assertTrue(it.hasNext()); it.next(); } @Test(timeout = 1000) public void testSingleSourceManyIterators() { TestScheduler scheduler = new TestScheduler(); Flowable<Long> source = Flowable.interval(1, TimeUnit.SECONDS, scheduler).take(10); Iterable<Long> iter = source.blockingMostRecent(-1L); for (int j = 0; j < 3; j++) { Iterator<Long> it = iter.iterator(); Assert.assertEquals(Long.valueOf(-1), it.next()); for (int i = 0; i < 9; i++) { scheduler.advanceTimeBy(1, TimeUnit.SECONDS); Assert.assertEquals(true, it.hasNext()); Assert.assertEquals(Long.valueOf(i), it.next()); } scheduler.advanceTimeBy(1, TimeUnit.SECONDS); Assert.assertEquals(false, it.hasNext()); } } @Test public void empty() { Iterator<Integer> it = Flowable.<Integer>empty() .blockingMostRecent(1) .iterator(); try { it.next(); fail("Should have thrown"); } catch (NoSuchElementException ex) { } try { it.remove(); fail("Should have thrown"); } catch (UnsupportedOperationException ex) { } }
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; }
@Test(expected = InternalError.class) public void throwIfThrowable() throws Exception { ExceptionHelper.<Exception>throwIfThrowable(new InternalError()); }
FlowableFlatMap extends AbstractFlowableWithUpstream<T, U> { public static <T, U> RelaxedSubscriber<T> subscribe(Subscriber<? super U> s, Function<? super T, ? extends Publisher<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) { return new MergeSubscriber<T, U>(s, mapper, delayErrors, maxConcurrency, bufferSize); } FlowableFlatMap(Flowable<T> source, Function<? super T, ? extends Publisher<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize); static RelaxedSubscriber<T> subscribe(Subscriber<? super U> s, Function<? super T, ? extends Publisher<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize); }
@Test public void testNormal() { Subscriber<Object> o = TestHelper.mockSubscriber(); final List<Integer> list = Arrays.asList(1, 2, 3); Function<Integer, List<Integer>> func = new Function<Integer, List<Integer>>() { @Override public List<Integer> apply(Integer t1) { return list; } }; BiFunction<Integer, Integer, Integer> resFunc = new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { return t1 | t2; } }; List<Integer> source = Arrays.asList(16, 32, 64); Flowable.fromIterable(source).flatMapIterable(func, resFunc).subscribe(o); for (Integer s : source) { for (Integer v : list) { verify(o).onNext(s | v); } } verify(o).onComplete(); verify(o, never()).onError(any(Throwable.class)); } @Test public void testCollectionFunctionThrows() { Subscriber<Object> o = TestHelper.mockSubscriber(); Function<Integer, List<Integer>> func = new Function<Integer, List<Integer>>() { @Override public List<Integer> apply(Integer t1) { throw new TestException(); } }; BiFunction<Integer, Integer, Integer> resFunc = new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { return t1 | t2; } }; List<Integer> source = Arrays.asList(16, 32, 64); Flowable.fromIterable(source).flatMapIterable(func, resFunc).subscribe(o); verify(o, never()).onComplete(); verify(o, never()).onNext(any()); verify(o).onError(any(TestException.class)); } @Test public void testResultFunctionThrows() { Subscriber<Object> o = TestHelper.mockSubscriber(); final List<Integer> list = Arrays.asList(1, 2, 3); Function<Integer, List<Integer>> func = new Function<Integer, List<Integer>>() { @Override public List<Integer> apply(Integer t1) { return list; } }; BiFunction<Integer, Integer, Integer> resFunc = new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { throw new TestException(); } }; List<Integer> source = Arrays.asList(16, 32, 64); Flowable.fromIterable(source).flatMapIterable(func, resFunc).subscribe(o); verify(o, never()).onComplete(); verify(o, never()).onNext(any()); verify(o).onError(any(TestException.class)); } @Test public void testMergeError() { Subscriber<Object> o = TestHelper.mockSubscriber(); Function<Integer, Flowable<Integer>> func = new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer t1) { return Flowable.error(new TestException()); } }; BiFunction<Integer, Integer, Integer> resFunc = new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { return t1 | t2; } }; List<Integer> source = Arrays.asList(16, 32, 64); Flowable.fromIterable(source).flatMap(func, resFunc).subscribe(o); verify(o, never()).onComplete(); verify(o, never()).onNext(any()); verify(o).onError(any(TestException.class)); } @Test public void testFlatMapTransformsNormal() { Flowable<Integer> onNext = Flowable.fromIterable(Arrays.asList(1, 2, 3)); Flowable<Integer> onComplete = Flowable.fromIterable(Arrays.asList(4)); Flowable<Integer> onError = Flowable.fromIterable(Arrays.asList(5)); Flowable<Integer> source = Flowable.fromIterable(Arrays.asList(10, 20, 30)); Subscriber<Object> o = TestHelper.mockSubscriber(); source.flatMap(just(onNext), just(onError), just0(onComplete)).subscribe(o); verify(o, times(3)).onNext(1); verify(o, times(3)).onNext(2); verify(o, times(3)).onNext(3); verify(o).onNext(4); verify(o).onComplete(); verify(o, never()).onNext(5); verify(o, never()).onError(any(Throwable.class)); } @Test public void testFlatMapTransformsException() { Flowable<Integer> onNext = Flowable.fromIterable(Arrays.asList(1, 2, 3)); Flowable<Integer> onComplete = Flowable.fromIterable(Arrays.asList(4)); Flowable<Integer> onError = Flowable.fromIterable(Arrays.asList(5)); Flowable<Integer> source = Flowable.concat( Flowable.fromIterable(Arrays.asList(10, 20, 30)), Flowable.<Integer> error(new RuntimeException("Forced failure!")) ); Subscriber<Object> o = TestHelper.mockSubscriber(); source.flatMap(just(onNext), just(onError), just0(onComplete)).subscribe(o); verify(o, times(3)).onNext(1); verify(o, times(3)).onNext(2); verify(o, times(3)).onNext(3); verify(o).onNext(5); verify(o).onComplete(); verify(o, never()).onNext(4); verify(o, never()).onError(any(Throwable.class)); } @Test public void testFlatMapTransformsOnNextFuncThrows() { Flowable<Integer> onComplete = Flowable.fromIterable(Arrays.asList(4)); Flowable<Integer> onError = Flowable.fromIterable(Arrays.asList(5)); Flowable<Integer> source = Flowable.fromIterable(Arrays.asList(10, 20, 30)); Subscriber<Object> o = TestHelper.mockSubscriber(); source.flatMap(funcThrow(1, onError), just(onError), just0(onComplete)).subscribe(o); verify(o).onError(any(TestException.class)); verify(o, never()).onNext(any()); verify(o, never()).onComplete(); } @Test public void testFlatMapTransformsOnErrorFuncThrows() { Flowable<Integer> onNext = Flowable.fromIterable(Arrays.asList(1, 2, 3)); Flowable<Integer> onComplete = Flowable.fromIterable(Arrays.asList(4)); Flowable<Integer> onError = Flowable.fromIterable(Arrays.asList(5)); Flowable<Integer> source = Flowable.error(new TestException()); Subscriber<Object> o = TestHelper.mockSubscriber(); source.flatMap(just(onNext), funcThrow((Throwable) null, onError), just0(onComplete)).subscribe(o); verify(o).onError(any(CompositeException.class)); verify(o, never()).onNext(any()); verify(o, never()).onComplete(); } @Test public void testFlatMapTransformsOnCompletedFuncThrows() { Flowable<Integer> onNext = Flowable.fromIterable(Arrays.asList(1, 2, 3)); Flowable<Integer> onComplete = Flowable.fromIterable(Arrays.asList(4)); Flowable<Integer> onError = Flowable.fromIterable(Arrays.asList(5)); Flowable<Integer> source = Flowable.fromIterable(Arrays.<Integer> asList()); Subscriber<Object> o = TestHelper.mockSubscriber(); source.flatMap(just(onNext), just(onError), funcThrow0(onComplete)).subscribe(o); verify(o).onError(any(TestException.class)); verify(o, never()).onNext(any()); verify(o, never()).onComplete(); } @Test public void testFlatMapTransformsMergeException() { Flowable<Integer> onNext = Flowable.error(new TestException()); Flowable<Integer> onComplete = Flowable.fromIterable(Arrays.asList(4)); Flowable<Integer> onError = Flowable.fromIterable(Arrays.asList(5)); Flowable<Integer> source = Flowable.fromIterable(Arrays.asList(10, 20, 30)); Subscriber<Object> o = TestHelper.mockSubscriber(); source.flatMap(just(onNext), just(onError), funcThrow0(onComplete)).subscribe(o); verify(o).onError(any(TestException.class)); verify(o, never()).onNext(any()); verify(o, never()).onComplete(); } @Test public void testFlatMapMaxConcurrent() { final int m = 4; final AtomicInteger subscriptionCount = new AtomicInteger(); Flowable<Integer> source = Flowable.range(1, 10) .flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer t1) { return composer(Flowable.range(t1 * 10, 2), subscriptionCount, m) .subscribeOn(Schedulers.computation()); } }, m); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); source.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); Set<Integer> expected = new HashSet<Integer>(Arrays.asList( 10, 11, 20, 21, 30, 31, 40, 41, 50, 51, 60, 61, 70, 71, 80, 81, 90, 91, 100, 101 )); Assert.assertEquals(expected.size(), ts.valueCount()); Assert.assertTrue(expected.containsAll(ts.values())); } @Test public void testFlatMapSelectorMaxConcurrent() { final int m = 4; final AtomicInteger subscriptionCount = new AtomicInteger(); Flowable<Integer> source = Flowable.range(1, 10) .flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer t1) { return composer(Flowable.range(t1 * 10, 2), subscriptionCount, m) .subscribeOn(Schedulers.computation()); } }, new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { return t1 * 1000 + t2; } }, m); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); source.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); Set<Integer> expected = new HashSet<Integer>(Arrays.asList( 1010, 1011, 2020, 2021, 3030, 3031, 4040, 4041, 5050, 5051, 6060, 6061, 7070, 7071, 8080, 8081, 9090, 9091, 10100, 10101 )); Assert.assertEquals(expected.size(), ts.valueCount()); System.out.println("--> testFlatMapSelectorMaxConcurrent: " + ts.values()); Assert.assertTrue(expected.containsAll(ts.values())); } @Test public void testFlatMapTransformsMaxConcurrentNormal() { final int m = 2; final AtomicInteger subscriptionCount = new AtomicInteger(); Flowable<Integer> onNext = composer( Flowable.fromIterable(Arrays.asList(1, 2, 3)) .observeOn(Schedulers.computation()) , subscriptionCount, m) .subscribeOn(Schedulers.computation()) ; Flowable<Integer> onComplete = composer(Flowable.fromIterable(Arrays.asList(4)), subscriptionCount, m) .subscribeOn(Schedulers.computation()); Flowable<Integer> onError = Flowable.fromIterable(Arrays.asList(5)); Flowable<Integer> source = Flowable.fromIterable(Arrays.asList(10, 20, 30)); Subscriber<Object> o = TestHelper.mockSubscriber(); TestSubscriber<Object> ts = new TestSubscriber<Object>(o); Function<Integer, Flowable<Integer>> just = just(onNext); Function<Throwable, Flowable<Integer>> just2 = just(onError); Callable<Flowable<Integer>> just0 = just0(onComplete); source.flatMap(just, just2, just0, m).subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertTerminated(); verify(o, times(3)).onNext(1); verify(o, times(3)).onNext(2); verify(o, times(3)).onNext(3); verify(o).onNext(4); verify(o).onComplete(); verify(o, never()).onNext(5); verify(o, never()).onError(any(Throwable.class)); } @Ignore("Don't care for any reordering") @Test(timeout = 10000) public void flatMapRangeAsyncLoop() { for (int i = 0; i < 2000; i++) { if (i % 10 == 0) { System.out.println("flatMapRangeAsyncLoop > " + i); } TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(0, 1000) .flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer t) { return Flowable.just(t); } }) .observeOn(Schedulers.computation()) .subscribe(ts); ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS); if (ts.completions() == 0) { System.out.println(ts.valueCount()); } ts.assertTerminated(); ts.assertNoErrors(); List<Integer> list = ts.values(); assertEquals(1000, list.size()); boolean f = false; for (int j = 0; j < list.size(); j++) { if (list.get(j) != j) { System.out.println(j + " " + list.get(j)); f = true; } } if (f) { Assert.fail("Results are out of order!"); } } } @Test(timeout = 30000) public void flatMapRangeMixedAsyncLoop() { for (int i = 0; i < 2000; i++) { if (i % 10 == 0) { System.out.println("flatMapRangeAsyncLoop > " + i); } TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(0, 1000) .flatMap(new Function<Integer, Flowable<Integer>>() { final Random rnd = new Random(); @Override public Flowable<Integer> apply(Integer t) { Flowable<Integer> r = Flowable.just(t); if (rnd.nextBoolean()) { r = r.hide(); } return r; } }) .observeOn(Schedulers.computation()) .subscribe(ts); ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS); if (ts.completions() == 0) { System.out.println(ts.valueCount()); } ts.assertTerminated(); ts.assertNoErrors(); List<Integer> list = ts.values(); if (list.size() < 1000) { Set<Integer> set = new HashSet<Integer>(list); for (int j = 0; j < 1000; j++) { if (!set.contains(j)) { System.out.println(j + " missing"); } } } assertEquals(1000, list.size()); } } @Test public void flatMapIntPassthruAsync() { for (int i = 0;i < 1000; i++) { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(1, 1000).flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer t) { return Flowable.just(1).subscribeOn(Schedulers.computation()); } }).subscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertComplete(); ts.assertValueCount(1000); } } @Test public void flatMapTwoNestedSync() { for (final int n : new int[] { 1, 1000, 1000000 }) { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.just(1, 2).flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer t) { return Flowable.range(1, n); } }).subscribe(ts); System.out.println("flatMapTwoNestedSync >> @ " + n); ts.assertNoErrors(); ts.assertComplete(); ts.assertValueCount(n * 2); } } @Test public void justEmptyMixture() { TestSubscriber<Integer> ts = TestSubscriber.create(); Flowable.range(0, 4 * Flowable.bufferSize()) .flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer v) { return (v & 1) == 0 ? Flowable.<Integer>empty() : Flowable.just(v); } }) .subscribe(ts); ts.assertValueCount(2 * Flowable.bufferSize()); ts.assertNoErrors(); ts.assertComplete(); int j = 1; for (Integer v : ts.values()) { Assert.assertEquals(j, v.intValue()); j += 2; } } @Test public void rangeEmptyMixture() { TestSubscriber<Integer> ts = TestSubscriber.create(); Flowable.range(0, 4 * Flowable.bufferSize()) .flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer v) { return (v & 1) == 0 ? Flowable.<Integer>empty() : Flowable.range(v, 2); } }) .subscribe(ts); ts.assertValueCount(4 * Flowable.bufferSize()); ts.assertNoErrors(); ts.assertComplete(); int j = 1; List<Integer> list = ts.values(); for (int i = 0; i < list.size(); i += 2) { Assert.assertEquals(j, list.get(i).intValue()); Assert.assertEquals(j + 1, list.get(i + 1).intValue()); j += 2; } } @Test public void justEmptyMixtureMaxConcurrent() { TestSubscriber<Integer> ts = TestSubscriber.create(); Flowable.range(0, 4 * Flowable.bufferSize()) .flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer v) { return (v & 1) == 0 ? Flowable.<Integer>empty() : Flowable.just(v); } }, 16) .subscribe(ts); ts.assertValueCount(2 * Flowable.bufferSize()); ts.assertNoErrors(); ts.assertComplete(); int j = 1; for (Integer v : ts.values()) { Assert.assertEquals(j, v.intValue()); j += 2; } } @Test public void rangeEmptyMixtureMaxConcurrent() { TestSubscriber<Integer> ts = TestSubscriber.create(); Flowable.range(0, 4 * Flowable.bufferSize()) .flatMap(new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer v) { return (v & 1) == 0 ? Flowable.<Integer>empty() : Flowable.range(v, 2); } }, 16) .subscribe(ts); ts.assertValueCount(4 * Flowable.bufferSize()); ts.assertNoErrors(); ts.assertComplete(); int j = 1; List<Integer> list = ts.values(); for (int i = 0; i < list.size(); i += 2) { Assert.assertEquals(j, list.get(i).intValue()); Assert.assertEquals(j + 1, list.get(i + 1).intValue()); j += 2; } } @Test public void castCrashUnsubscribes() { PublishProcessor<Integer> ps = PublishProcessor.create(); TestSubscriber<Integer> ts = TestSubscriber.create(); ps.flatMap(new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer t) { throw new TestException(); } }, new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { return t1; } }).subscribe(ts); Assert.assertTrue("Not subscribed?", ps.hasSubscribers()); ps.onNext(1); Assert.assertFalse("Subscribed?", ps.hasSubscribers()); ts.assertError(TestException.class); } @Test public void scalarReentrant() { final PublishProcessor<Flowable<Integer>> ps = PublishProcessor.create(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); if (t == 1) { ps.onNext(Flowable.just(2)); } } }; Flowable.merge(ps) .subscribe(to); ps.onNext(Flowable.just(1)); ps.onComplete(); to.assertResult(1, 2); } @Test public void scalarReentrant2() { final PublishProcessor<Flowable<Integer>> ps = PublishProcessor.create(); TestSubscriber<Integer> to = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); if (t == 1) { ps.onNext(Flowable.just(2)); } } }; Flowable.merge(ps, 2) .subscribe(to); ps.onNext(Flowable.just(1)); ps.onComplete(); to.assertResult(1, 2); }
AtomicThrowable extends AtomicReference<Throwable> { public boolean isTerminated() { return get() == ExceptionHelper.TERMINATED; } boolean addThrowable(Throwable t); Throwable terminate(); boolean isTerminated(); }
@Test public void isTerminated() { AtomicThrowable ex = new AtomicThrowable(); assertFalse(ex.isTerminated()); assertNull(ex.terminate()); assertTrue(ex.isTerminated()); }
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(); }
@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()); }
FlowableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(Publisher<T> source, Subscriber<? super R> subscriber, Function<? super T, ? extends Publisher<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); EmptySubscription.error(ex, subscriber); return true; } if (t == null) { EmptySubscription.complete(subscriber); return true; } Publisher<? extends R> r; try { r = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null Publisher"); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); EmptySubscription.error(ex, subscriber); return true; } if (r instanceof Callable) { R u; try { u = ((Callable<R>)r).call(); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); EmptySubscription.error(ex, subscriber); return true; } if (u == null) { EmptySubscription.complete(subscriber); return true; } subscriber.onSubscribe(new ScalarSubscription<R>(subscriber, u)); } else { r.subscribe(subscriber); } return true; } return false; } 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); }
@Test public void tryScalarXMap() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); assertTrue(FlowableScalarXMap.tryScalarXMapSubscribe(new CallablePublisher(), ts, new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer f) throws Exception { return Flowable.just(1); } })); ts.assertFailure(TestException.class); } @Test public void emptyXMap() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); assertTrue(FlowableScalarXMap.tryScalarXMapSubscribe(new EmptyCallablePublisher(), ts, new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer f) throws Exception { return Flowable.just(1); } })); ts.assertResult(); } @Test public void mapperCrashes() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); assertTrue(FlowableScalarXMap.tryScalarXMapSubscribe(new OneCallablePublisher(), ts, new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer f) throws Exception { throw new TestException(); } })); ts.assertFailure(TestException.class); } @Test public void mapperToJust() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); assertTrue(FlowableScalarXMap.tryScalarXMapSubscribe(new OneCallablePublisher(), ts, new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer f) throws Exception { return Flowable.just(1); } })); ts.assertResult(1); } @Test public void mapperToEmpty() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); assertTrue(FlowableScalarXMap.tryScalarXMapSubscribe(new OneCallablePublisher(), ts, new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer f) throws Exception { return Flowable.empty(); } })); ts.assertResult(); } @Test public void mapperToCrashingCallable() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); assertTrue(FlowableScalarXMap.tryScalarXMapSubscribe(new OneCallablePublisher(), ts, new Function<Integer, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Integer f) throws Exception { return new CallablePublisher(); } })); ts.assertFailure(TestException.class); }
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); }
@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); }
FlowableFromIterable extends Flowable<T> { public static <T> void subscribe(Subscriber<? super T> s, Iterator<? extends T> it) { boolean hasNext; try { hasNext = it.hasNext(); } catch (Throwable e) { Exceptions.throwIfFatal(e); EmptySubscription.error(e, s); return; } if (!hasNext) { EmptySubscription.complete(s); return; } if (s instanceof ConditionalSubscriber) { s.onSubscribe(new IteratorConditionalSubscription<T>( (ConditionalSubscriber<? super T>)s, it)); } else { s.onSubscribe(new IteratorSubscription<T>(s, it)); } } FlowableFromIterable(Iterable<? extends T> source); @Override void subscribeActual(Subscriber<? super T> s); static void subscribe(Subscriber<? super T> s, Iterator<? extends T> it); }
@Test public void testListIterable() { Flowable<String> flowable = Flowable.fromIterable(Arrays.<String> asList("one", "two", "three")); Subscriber<String> observer = TestHelper.mockSubscriber(); flowable.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(); } @Test public void testRawIterable() { Iterable<String> it = new Iterable<String>() { @Override public Iterator<String> iterator() { return new Iterator<String>() { int i; @Override public boolean hasNext() { return i < 3; } @Override public String next() { return String.valueOf(++i); } @Override public void remove() { } }; } }; Flowable<String> flowable = Flowable.fromIterable(it); Subscriber<String> observer = TestHelper.mockSubscriber(); flowable.subscribe(observer); verify(observer, times(1)).onNext("1"); verify(observer, times(1)).onNext("2"); verify(observer, times(1)).onNext("3"); verify(observer, Mockito.never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); } @Test public void testObservableFromIterable() { Flowable<String> flowable = Flowable.fromIterable(Arrays.<String> asList("one", "two", "three")); Subscriber<String> observer = TestHelper.mockSubscriber(); flowable.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(); } @Test public void testBackpressureViaRequest() { ArrayList<Integer> list = new ArrayList<Integer>(Flowable.bufferSize()); for (int i = 1; i <= Flowable.bufferSize() + 1; i++) { list.add(i); } Flowable<Integer> o = Flowable.fromIterable(list); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); ts.assertNoValues(); ts.request(1); o.subscribe(ts); ts.assertValue(1); ts.request(2); ts.assertValues(1, 2, 3); ts.request(3); ts.assertValues(1, 2, 3, 4, 5, 6); ts.request(list.size()); ts.assertTerminated(); } @Test public void testNoBackpressure() { Flowable<Integer> o = Flowable.fromIterable(Arrays.asList(1, 2, 3, 4, 5)); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); ts.assertNoValues(); ts.request(Long.MAX_VALUE); o.subscribe(ts); ts.assertValues(1, 2, 3, 4, 5); ts.assertTerminated(); } @Test public void testSubscribeMultipleTimes() { Flowable<Integer> o = Flowable.fromIterable(Arrays.asList(1, 2, 3)); for (int i = 0; i < 10; i++) { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); o.subscribe(ts); ts.assertValues(1, 2, 3); ts.assertNoErrors(); ts.assertComplete(); } } @Test public void testFromIterableRequestOverflow() throws InterruptedException { Flowable<Integer> o = Flowable.fromIterable(Arrays.asList(1,2,3,4)); final int expectedCount = 4; final CountDownLatch latch = new CountDownLatch(expectedCount); o.subscribeOn(Schedulers.computation()) .subscribe(new DefaultSubscriber<Integer>() { @Override public void onStart() { request(2); } @Override public void onComplete() { } @Override public void onError(Throwable e) { throw new RuntimeException(e); } @Override public void onNext(Integer t) { latch.countDown(); request(Long.MAX_VALUE - 1); }}); assertTrue(latch.await(10, TimeUnit.SECONDS)); } @Test public void testFromEmptyIterableWhenZeroRequestedShouldStillEmitOnCompletedEagerly() { final AtomicBoolean completed = new AtomicBoolean(false); Flowable.fromIterable(Collections.emptyList()).subscribe(new DefaultSubscriber<Object>() { @Override public void onStart() { } @Override public void onComplete() { completed.set(true); } @Override public void onError(Throwable e) { } @Override public void onNext(Object t) { }}); assertTrue(completed.get()); } @Test public void testDoesNotCallIteratorHasNextMoreThanRequiredWithBackpressure() { final AtomicBoolean called = new AtomicBoolean(false); Iterable<Integer> iterable = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { int count = 1; @Override public void remove() { } @Override public boolean hasNext() { if (count > 1) { called.set(true); return false; } return true; } @Override public Integer next() { return count++; } }; } }; Flowable.fromIterable(iterable).take(1).subscribe(); assertFalse(called.get()); } @Test public void testDoesNotCallIteratorHasNextMoreThanRequiredFastPath() { final AtomicBoolean called = new AtomicBoolean(false); Iterable<Integer> iterable = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { @Override public void remove() { } int count = 1; @Override public boolean hasNext() { if (count > 1) { called.set(true); return false; } return true; } @Override public Integer next() { return count++; } }; } }; Flowable.fromIterable(iterable).subscribe(new DefaultSubscriber<Integer>() { @Override public void onComplete() { } @Override public void onError(Throwable e) { } @Override public void onNext(Integer t) { cancel(); } }); assertFalse(called.get()); } @Test public void getIteratorThrows() { Iterable<Integer> it = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { throw new TestException("Forced failure"); } }; TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.fromIterable(it).subscribe(ts); ts.assertNoValues(); ts.assertError(TestException.class); ts.assertNotComplete(); } @Test public void hasNextThrowsImmediately() { Iterable<Integer> it = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { @Override public boolean hasNext() { throw new TestException("Forced failure"); } @Override public Integer next() { return null; } @Override public void remove() { } }; } }; TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.fromIterable(it).subscribe(ts); ts.assertNoValues(); ts.assertError(TestException.class); ts.assertNotComplete(); } @Test public void hasNextThrowsSecondTimeFastpath() { Iterable<Integer> it = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { int count; @Override public boolean hasNext() { if (++count >= 2) { throw new TestException("Forced failure"); } return true; } @Override public Integer next() { return 1; } @Override public void remove() { } }; } }; TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.fromIterable(it).subscribe(ts); ts.assertValues(1); ts.assertError(TestException.class); ts.assertNotComplete(); } @Test public void hasNextThrowsSecondTimeSlowpath() { Iterable<Integer> it = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { int count; @Override public boolean hasNext() { if (++count >= 2) { throw new TestException("Forced failure"); } return true; } @Override public Integer next() { return 1; } @Override public void remove() { } }; } }; TestSubscriber<Integer> ts = new TestSubscriber<Integer>(5); Flowable.fromIterable(it).subscribe(ts); ts.assertValues(1); ts.assertError(TestException.class); ts.assertNotComplete(); } @Test public void nextThrowsFastpath() { Iterable<Integer> it = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { @Override public boolean hasNext() { return true; } @Override public Integer next() { throw new TestException("Forced failure"); } @Override public void remove() { } }; } }; TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.fromIterable(it).subscribe(ts); ts.assertNoValues(); ts.assertError(TestException.class); ts.assertNotComplete(); } @Test public void nextThrowsSlowpath() { Iterable<Integer> it = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { @Override public boolean hasNext() { return true; } @Override public Integer next() { throw new TestException("Forced failure"); } @Override public void remove() { } }; } }; TestSubscriber<Integer> ts = new TestSubscriber<Integer>(5); Flowable.fromIterable(it).subscribe(ts); ts.assertNoValues(); ts.assertError(TestException.class); ts.assertNotComplete(); } @Test public void deadOnArrival() { Iterable<Integer> it = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { @Override public boolean hasNext() { return true; } @Override public Integer next() { throw new NoSuchElementException(); } @Override public void remove() { } }; } }; TestSubscriber<Integer> ts = new TestSubscriber<Integer>(5); ts.cancel(); Flowable.fromIterable(it).subscribe(ts); ts.assertNoValues(); ts.assertNoErrors(); ts.assertNotComplete(); } @Test public void fusionWithConcatMap() { TestSubscriber<Integer> to = new TestSubscriber<Integer>(); Flowable.fromIterable(Arrays.asList(1, 2, 3, 4)).concatMap( new Function<Integer, Flowable <Integer>>() { @Override public Flowable<Integer> apply(Integer v) { return Flowable.range(v, 2); } }).subscribe(to); to.assertValues(1, 2, 2, 3, 3, 4, 4, 5); to.assertNoErrors(); to.assertComplete(); } @Test public void fusedAPICalls() { Flowable.fromIterable(Arrays.asList(1, 2, 3)) .subscribe(new RelaxedSubscriber<Integer>() { @Override public void onSubscribe(Subscription s) { @SuppressWarnings("unchecked") FusedQueueSubscription<Integer> qs = (FusedQueueSubscription<Integer>)s; assertFalse(qs.isEmpty()); try { assertEquals(1, qs.poll().intValue()); } catch (Throwable ex) { throw new AssertionError(ex); } assertFalse(qs.isEmpty()); qs.clear(); List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { qs.request(-99); TestCommonHelper.assertError(errors, 0, IllegalArgumentException.class, "n > 0 required but it was -99"); } finally { RxJavaCommonPlugins.reset(); } } @Override public void onNext(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }); } @Test public void requestRaceConditional() { for (int i = 0; i < 500; i++) { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); Runnable r = new Runnable() { @Override public void run() { ts.request(1); } }; Flowable.fromIterable(Arrays.asList(1, 2, 3, 4)) .filter(Functions.alwaysTrue()) .subscribe(ts); TestCommonHelper.race(r, r, Schedulers.single()); } } @Test public void requestRaceConditional2() { for (int i = 0; i < 500; i++) { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); Runnable r = new Runnable() { @Override public void run() { ts.request(1); } }; Flowable.fromIterable(Arrays.asList(1, 2, 3, 4)) .filter(Functions.alwaysFalse()) .subscribe(ts); TestCommonHelper.race(r, r, Schedulers.single()); } } @Test public void requestCancelConditionalRace() { for (int i = 0; i < 500; i++) { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); Runnable r1 = new Runnable() { @Override public void run() { ts.request(1); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; Flowable.fromIterable(Arrays.asList(1, 2, 3, 4)) .filter(Functions.alwaysTrue()) .subscribe(ts); TestCommonHelper.race(r1, r2, Schedulers.single()); } } @Test public void requestCancelConditionalRace2() { for (int i = 0; i < 500; i++) { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); Runnable r1 = new Runnable() { @Override public void run() { ts.request(Long.MAX_VALUE); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; Flowable.fromIterable(Arrays.asList(1, 2, 3, 4)) .filter(Functions.alwaysTrue()) .subscribe(ts); TestCommonHelper.race(r1, r2, Schedulers.single()); } } @Test public void requestCancelRace() { for (int i = 0; i < 500; i++) { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); Runnable r1 = new Runnable() { @Override public void run() { ts.request(1); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; Flowable.fromIterable(Arrays.asList(1, 2, 3, 4)) .subscribe(ts); TestCommonHelper.race(r1, r2, Schedulers.single()); } } @Test public void requestCancelRace2() { for (int i = 0; i < 500; i++) { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); Runnable r1 = new Runnable() { @Override public void run() { ts.request(Long.MAX_VALUE); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; Flowable.fromIterable(Arrays.asList(1, 2, 3, 4)) .subscribe(ts); TestCommonHelper.race(r1, r2, Schedulers.single()); } } @Test public void fusionRejected() { TestSubscriber<Integer> to = SubscriberFusion.newTest(FusedQueueSubscription.ASYNC); Flowable.fromIterable(Arrays.asList(1, 2, 3)) .subscribe(to); SubscriberFusion.assertFusion(to, FusedQueueSubscription.NONE) .assertResult(1, 2, 3); } @Test public void fusionClear() { Flowable.fromIterable(Arrays.asList(1, 2, 3)) .subscribe(new RelaxedSubscriber<Integer>() { @Override public void onSubscribe(Subscription d) { @SuppressWarnings("unchecked") FusedQueueSubscription<Integer> qd = (FusedQueueSubscription<Integer>)d; qd.requestFusion(FusedQueueSubscription.ANY); try { assertEquals(1, qd.poll().intValue()); } catch (Throwable ex) { fail(ex.toString()); } qd.clear(); try { assertNull(qd.poll()); } catch (Throwable ex) { fail(ex.toString()); } } @Override public void onNext(Integer value) { } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); } @Test public void hasNextCancels() { final TestSubscriber<Integer> to = new TestSubscriber<Integer>(); Flowable.fromIterable(new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return new Iterator<Integer>() { int count; @Override public boolean hasNext() { if (++count == 2) { to.cancel(); } return true; } @Override public Integer next() { return 1; } @Override public void remove() { throw new UnsupportedOperationException(); } }; } }) .subscribe(to); to.assertValue(1) .assertNoErrors() .assertNotComplete(); }
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); }
@Test public void hashCodeOf() { assertEquals(0, ObjectHelper.hashCode(null)); assertEquals(((Integer)1).hashCode(), ObjectHelper.hashCode(1)); }
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); }
@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")); }
FlowablePublish extends ConnectableFlowable<T> implements HasUpstreamPublisher<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishSubscriber<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishSubscriber<T> u = new PublishSubscriber<T>(current, bufferSize); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.shouldConnect.get() && ps.shouldConnect.compareAndSet(false, true); break; } try { connection.accept(ps); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOrThrow(ex); } if (doConnect) { source.subscribe(ps); } } 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); }
@Test public void testPublish() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); ConnectableFlowable<String> o = Flowable.unsafeCreate(new Publisher<String>() { @Override public void subscribe(final Subscriber<? super String> observer) { observer.onSubscribe(new BooleanSubscription()); new Thread(new Runnable() { @Override public void run() { counter.incrementAndGet(); observer.onNext("one"); observer.onComplete(); } }).start(); } }).publish(); final CountDownLatch latch = new CountDownLatch(2); o.subscribe(new Consumer<String>() { @Override public void accept(String v) { assertEquals("one", v); latch.countDown(); } }); o.subscribe(new Consumer<String>() { @Override public void accept(String v) { assertEquals("one", v); latch.countDown(); } }); Disposable s = o.connect(); try { if (!latch.await(1000, TimeUnit.MILLISECONDS)) { fail("subscriptions did not receive values"); } assertEquals(1, counter.get()); } finally { s.dispose(); } } @Test public void testBackpressureFastSlow() { ConnectableFlowable<Integer> is = Flowable.range(1, Flowable.bufferSize() * 2).publish(); Flowable<Integer> fast = is.observeOn(Schedulers.computation()) .doOnComplete(new Action() { @Override public void run() { System.out.println("^^^^^^^^^^^^^ completed FAST"); } }); Flowable<Integer> slow = is.observeOn(Schedulers.computation()).map(new Function<Integer, Integer>() { int c; @Override public Integer apply(Integer i) { if (c == 0) { try { Thread.sleep(500); } catch (InterruptedException e) { } } c++; return i; } }).doOnComplete(new Action() { @Override public void run() { System.out.println("^^^^^^^^^^^^^ completed SLOW"); } }); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.merge(fast, slow).subscribe(ts); is.connect(); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(Flowable.bufferSize() * 4, ts.valueCount()); } @Test public void testTakeUntilWithPublishedStream() { Flowable<Integer> xs = Flowable.range(0, Flowable.bufferSize() * 2); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); ConnectableFlowable<Integer> xsp = xs.publish(); xsp.takeUntil(xsp.skipWhile(new Predicate<Integer>() { @Override public boolean test(Integer i) { return i <= 3; } })).subscribe(ts); xsp.connect(); System.out.println(ts.values()); } @Test public void testConnectWithNoSubscriber() { TestScheduler scheduler = new TestScheduler(); ConnectableFlowable<Long> co = Flowable.interval(10, 10, TimeUnit.MILLISECONDS, scheduler).take(3).publish(); co.connect(); scheduler.advanceTimeBy(15, TimeUnit.MILLISECONDS); TestSubscriber<Long> subscriber = new TestSubscriber<Long>(); co.subscribe(subscriber); scheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS); subscriber.assertValues(1L, 2L); subscriber.assertNoErrors(); subscriber.assertTerminated(); } @Test public void testSubscribeAfterDisconnectThenConnect() { ConnectableFlowable<Integer> source = Flowable.just(1).publish(); TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(); source.subscribe(ts1); Disposable s = source.connect(); ts1.assertValue(1); ts1.assertNoErrors(); ts1.assertTerminated(); TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>(); source.subscribe(ts2); Disposable s2 = source.connect(); ts2.assertValue(1); ts2.assertNoErrors(); ts2.assertTerminated(); System.out.println(s); System.out.println(s2); } @Test public void testNoSubscriberRetentionOnCompleted() { FlowablePublish<Integer> source = (FlowablePublish<Integer>)Flowable.just(1).publish(); TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(); source.subscribe(ts1); ts1.assertNoValues(); ts1.assertNoErrors(); ts1.assertNotComplete(); source.connect(); ts1.assertValue(1); ts1.assertNoErrors(); ts1.assertTerminated(); assertNull(source.current.get()); } @Test public void testNonNullConnection() { ConnectableFlowable<Object> source = Flowable.never().publish(); assertNotNull(source.connect()); assertNotNull(source.connect()); } @Test public void testNoDisconnectSomeoneElse() { ConnectableFlowable<Object> source = Flowable.never().publish(); Disposable s1 = source.connect(); Disposable s2 = source.connect(); s1.dispose(); Disposable s3 = source.connect(); s2.dispose(); assertTrue(checkPublishDisposed(s1)); assertTrue(checkPublishDisposed(s2)); assertFalse(checkPublishDisposed(s3)); } @Test public void testZeroRequested() { ConnectableFlowable<Integer> source = Flowable.just(1).publish(); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L); source.subscribe(ts); ts.assertNoValues(); ts.assertNoErrors(); ts.assertNotComplete(); source.connect(); ts.assertNoValues(); ts.assertNoErrors(); ts.assertNotComplete(); ts.request(5); ts.assertValue(1); ts.assertNoErrors(); ts.assertTerminated(); } @Test public void testConnectIsIdempotent() { final AtomicInteger calls = new AtomicInteger(); Flowable<Integer> source = Flowable.unsafeCreate(new Publisher<Integer>() { @Override public void subscribe(Subscriber<? super Integer> t) { t.onSubscribe(new BooleanSubscription()); calls.getAndIncrement(); } }); ConnectableFlowable<Integer> conn = source.publish(); assertEquals(0, calls.get()); conn.connect(); conn.connect(); assertEquals(1, calls.get()); conn.connect().dispose(); conn.connect(); conn.connect(); assertEquals(2, calls.get()); } @Test public void syncFusedObserveOn() { ConnectableFlowable<Integer> co = Flowable.range(0, 1000).publish(); Flowable<Integer> obs = co.observeOn(Schedulers.computation()); for (int i = 0; i < 1000; i++) { for (int j = 1; j < 6; j++) { List<TestSubscriber<Integer>> tss = new ArrayList<TestSubscriber<Integer>>(); for (int k = 1; k < j; k++) { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); tss.add(ts); obs.subscribe(ts); } Disposable s = co.connect(); for (TestSubscriber<Integer> ts : tss) { ts.awaitDone(5, TimeUnit.SECONDS) .assertSubscribed() .assertValueCount(1000) .assertNoErrors() .assertComplete(); } s.dispose(); } } } @Test public void syncFusedObserveOn2() { ConnectableFlowable<Integer> co = Flowable.range(0, 1000).publish(); Flowable<Integer> obs = co.observeOn(ImmediateThinScheduler.INSTANCE); for (int i = 0; i < 1000; i++) { for (int j = 1; j < 6; j++) { List<TestSubscriber<Integer>> tss = new ArrayList<TestSubscriber<Integer>>(); for (int k = 1; k < j; k++) { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); tss.add(ts); obs.subscribe(ts); } Disposable s = co.connect(); for (TestSubscriber<Integer> ts : tss) { ts.awaitDone(5, TimeUnit.SECONDS) .assertSubscribed() .assertValueCount(1000) .assertNoErrors() .assertComplete(); } s.dispose(); } } } @Test public void asyncFusedObserveOn() { ConnectableFlowable<Integer> co = Flowable.range(0, 1000).observeOn(ImmediateThinScheduler.INSTANCE).publish(); for (int i = 0; i < 1000; i++) { for (int j = 1; j < 6; j++) { List<TestSubscriber<Integer>> tss = new ArrayList<TestSubscriber<Integer>>(); for (int k = 1; k < j; k++) { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); tss.add(ts); co.subscribe(ts); } Disposable s = co.connect(); for (TestSubscriber<Integer> ts : tss) { ts.awaitDone(5, TimeUnit.SECONDS) .assertSubscribed() .assertValueCount(1000) .assertNoErrors() .assertComplete(); } s.dispose(); } } } @Test public void testObserveOn() { ConnectableFlowable<Integer> co = Flowable.range(0, 1000).hide().publish(); Flowable<Integer> obs = co.observeOn(Schedulers.computation()); for (int i = 0; i < 1000; i++) { for (int j = 1; j < 6; j++) { List<TestSubscriber<Integer>> tss = new ArrayList<TestSubscriber<Integer>>(); for (int k = 1; k < j; k++) { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); tss.add(ts); obs.subscribe(ts); } Disposable s = co.connect(); for (TestSubscriber<Integer> ts : tss) { ts.awaitDone(5, TimeUnit.SECONDS) .assertSubscribed() .assertValueCount(1000) .assertNoErrors() .assertComplete(); } s.dispose(); } } } @Test public void connectThrows() { ConnectableFlowable<Integer> co = Flowable.<Integer>empty().publish(); try { co.connect(new Consumer<Disposable>() { @Override public void accept(Disposable s) throws Exception { throw new TestException(); } }); } catch (TestException ex) { } } @Test public void empty() { ConnectableFlowable<Integer> co = Flowable.<Integer>empty().publish(); co.connect(); } @Test public void take() { ConnectableFlowable<Integer> co = Flowable.range(1, 2).publish(); TestSubscriber<Integer> to = co.take(1).test(); co.connect(); to.assertResult(1); } @Test public void noErrorLoss() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { ConnectableFlowable<Object> co = Flowable.error(new TestException()).publish(); co.connect(); TestCommonHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaCommonPlugins.reset(); } } @Test public void preNextConnect() { for (int i = 0; i < 500; i++) { final ConnectableFlowable<Integer> co = Flowable.<Integer>empty().publish(); co.connect(); Runnable r1 = new Runnable() { @Override public void run() { co.test(); } }; TestCommonHelper.race(r1, r1); } } @Test public void connectRace() { for (int i = 0; i < 500; i++) { final ConnectableFlowable<Integer> co = Flowable.<Integer>empty().publish(); Runnable r1 = new Runnable() { @Override public void run() { co.connect(); } }; TestCommonHelper.race(r1, r1); } } @Test public void delayedUpstreamOnSubscribe() { final Subscriber<?>[] sub = { null }; new Flowable<Integer>() { @Override protected void subscribeActual(Subscriber<? super Integer> s) { sub[0] = s; } } .publish() .connect() .dispose(); BooleanSubscription bs = new BooleanSubscription(); sub[0].onSubscribe(bs); assertTrue(bs.isCancelled()); }
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); }
@Test public void source() { Flowable<Integer> o = Flowable.never(); assertSame(o, (((HasUpstreamPublisher<?>)o.publish()).source())); }
FlowablePublish extends ConnectableFlowable<T> implements HasUpstreamPublisher<T> { public static <T> ConnectableFlowable<T> create(Flowable<T> source, final int bufferSize) { final AtomicReference<PublishSubscriber<T>> curr = new AtomicReference<PublishSubscriber<T>>(); Publisher<T> onSubscribe = new FlowablePublisher<T>(curr, bufferSize); return RxJavaFlowablePlugins.onAssembly(new FlowablePublish<T>(onSubscribe, source, curr, bufferSize)); } 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); }
@Test public void nextCancelRace() { for (int i = 0; i < 500; i++) { final PublishProcessor<Integer> ps = PublishProcessor.create(); final ConnectableFlowable<Integer> co = ps.publish(); final TestSubscriber<Integer> to = co.test(); Runnable r1 = new Runnable() { @Override public void run() { ps.onNext(1); } }; Runnable r2 = new Runnable() { @Override public void run() { to.cancel(); } }; TestCommonHelper.race(r1, r2); } } @Test public void selectorDisconnectsIndependentSource() { PublishProcessor<Integer> ps = PublishProcessor.create(); ps.publish(new Function<Flowable<Integer>, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Flowable<Integer> v) throws Exception { return Flowable.range(1, 2); } }) .test() .assertResult(1, 2); assertFalse(ps.hasSubscribers()); } @Test public void selectorInnerError() { PublishProcessor<Integer> ps = PublishProcessor.create(); ps.publish(new Function<Flowable<Integer>, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Flowable<Integer> v) throws Exception { return Flowable.error(new TestException()); } }) .test() .assertFailure(TestException.class); assertFalse(ps.hasSubscribers()); } @Test public void overflowQueue() { Flowable.create(new FlowableOnSubscribe<Object>() { @Override public void subscribe(FlowableEmitter<Object> s) throws Exception { for (int i = 0; i < 10; i++) { s.onNext(i); } } }, BackpressureStrategy.MISSING) .publish(8) .autoConnect() .test(0L) .assertFailure(MissingBackpressureException.class); }
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); }
@Test public void compare() { assertEquals(-1, ObjectHelper.compare(0, 2)); assertEquals(0, ObjectHelper.compare(0, 0)); assertEquals(1, ObjectHelper.compare(2, 0)); }
FlowableFromCallable extends Flowable<T> implements Callable<T> { @Override public T call() throws Exception { return ObjectHelper.requireNonNull(callable.call(), "The callable returned a null value"); } FlowableFromCallable(Callable<? extends T> callable); @Override void subscribeActual(Subscriber<? super T> s); @Override T call(); }
@SuppressWarnings("unchecked") @Test public void shouldNotInvokeFuncUntilSubscription() throws Exception { Callable<Object> func = mock(Callable.class); when(func.call()).thenReturn(new Object()); Flowable<Object> fromCallableFlowable = Flowable.fromCallable(func); verifyZeroInteractions(func); fromCallableFlowable.subscribe(); verify(func).call(); } @SuppressWarnings("unchecked") @Test public void shouldCallOnNextAndOnCompleted() throws Exception { Callable<String> func = mock(Callable.class); when(func.call()).thenReturn("test_value"); Flowable<String> fromCallableFlowable = Flowable.fromCallable(func); Subscriber<String> observer = TestHelper.mockSubscriber(); fromCallableFlowable.subscribe(observer); verify(observer).onNext("test_value"); verify(observer).onComplete(); verify(observer, never()).onError(any(Throwable.class)); } @SuppressWarnings("unchecked") @Test public void shouldCallOnError() throws Exception { Callable<Object> func = mock(Callable.class); Throwable throwable = new IllegalStateException("Test exception"); when(func.call()).thenThrow(throwable); Flowable<Object> fromCallableFlowable = Flowable.fromCallable(func); Subscriber<Object> observer = TestHelper.mockSubscriber(); fromCallableFlowable.subscribe(observer); verify(observer, never()).onNext(any()); verify(observer, never()).onComplete(); verify(observer).onError(throwable); } @SuppressWarnings("unchecked") @Test public void shouldNotDeliverResultIfSubscriberUnsubscribedBeforeEmission() throws Exception { Callable<String> func = mock(Callable.class); final CountDownLatch funcLatch = new CountDownLatch(1); final CountDownLatch observerLatch = new CountDownLatch(1); when(func.call()).thenAnswer(new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { observerLatch.countDown(); try { funcLatch.await(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return "should_not_be_delivered"; } }); Flowable<String> fromCallableFlowable = Flowable.fromCallable(func); Subscriber<String> observer = TestHelper.mockSubscriber(); TestSubscriber<String> outer = new TestSubscriber<String>(observer); fromCallableFlowable .subscribeOn(Schedulers.computation()) .subscribe(outer); observerLatch.await(); outer.cancel(); funcLatch.countDown(); verify(func).call(); verify(observer).onSubscribe(any(Subscription.class)); verifyNoMoreInteractions(observer); }
FlowableCache extends AbstractFlowableWithUpstream<T, T> { boolean hasSubscribers() { return state.subscribers.get().length != 0; } FlowableCache(Flowable<T> source, int capacityHint); }
@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()); }
AbstractFlowableWithUpstream extends Flowable<R> implements HasUpstreamPublisher<T> { @Override public final Publisher<T> source() { return source; } AbstractFlowableWithUpstream(Flowable<T> source); @Override final Publisher<T> source(); }
@SuppressWarnings("unchecked") @Test public void source() { Flowable<Integer> o = Flowable.just(1); assertSame(o, ((HasUpstreamPublisher<Integer>)o.map(Functions.<Integer>identity())).source()); }
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); }
@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]); }
ParallelRunOn extends ParallelFlowable<T> { @Override public void subscribe(Subscriber<? super T>[] subscribers) { if (!validate(subscribers)) { return; } int n = subscribers.length; @SuppressWarnings("unchecked") Subscriber<T>[] parents = new Subscriber[n]; int prefetch = this.prefetch; for (int i = 0; i < n; i++) { Subscriber<? super T> a = subscribers[i]; Worker w = scheduler.createWorker(); SpscArrayQueue<T> q = new SpscArrayQueue<T>(prefetch); if (a instanceof ConditionalSubscriber) { parents[i] = new RunOnConditionalSubscriber<T>((ConditionalSubscriber<? super T>)a, prefetch, q, w); } else { parents[i] = new RunOnSubscriber<T>(a, prefetch, q, w); } } source.subscribe(parents); } ParallelRunOn(ParallelFlowable<? extends T> parent, Scheduler scheduler, int prefetch); @Override void subscribe(Subscriber<? super T>[] subscribers); @Override int parallelism(); }
@SuppressWarnings("unchecked") @Test public void errorConditionalBackpressured() { TestSubscriber<Object> ts = new TestSubscriber<Object>(0L); Flowable.error(new TestException()) .parallel(1) .runOn(ImmediateThinScheduler.INSTANCE) .filter(Functions.alwaysTrue()) .subscribe(new Subscriber[] { ts }); ts .assertFailure(TestException.class); } @SuppressWarnings("unchecked") @Test public void emptyConditionalBackpressured() { TestSubscriber<Object> ts = new TestSubscriber<Object>(0L); Flowable.empty() .parallel(1) .runOn(ImmediateThinScheduler.INSTANCE) .filter(Functions.alwaysTrue()) .subscribe(new Subscriber[] { ts }); ts .assertResult(); } @SuppressWarnings("unchecked") @Test public void nextCancelRaceBackpressured() { for (int i = 0; i < 1000; i++) { final PublishProcessor<Integer> pp = PublishProcessor.create(); final TestSubscriber<Integer> ts = TestSubscriber.create(0L); pp.parallel(1) .runOn(Schedulers.computation()) .subscribe(new Subscriber[] { ts }); Runnable r1 = new Runnable() { @Override public void run() { pp.onNext(1); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; TestCommonHelper.race(r1, r2); } } @SuppressWarnings("unchecked") @Test public void nextCancelRaceBackpressuredConditional() { for (int i = 0; i < 1000; i++) { final PublishProcessor<Integer> pp = PublishProcessor.create(); final TestSubscriber<Integer> ts = TestSubscriber.create(0L); pp.parallel(1) .runOn(Schedulers.computation()) .filter(Functions.alwaysTrue()) .subscribe(new Subscriber[] { ts }); Runnable r1 = new Runnable() { @Override public void run() { pp.onNext(1); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; TestCommonHelper.race(r1, r2); } } @SuppressWarnings("unchecked") @Test public void normalCancelAfterRequest1() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1) { @Override public void onNext(Integer t) { super.onNext(t); cancel(); onComplete(); } }; Flowable.range(1, 5) .parallel(1) .runOn(ImmediateThinScheduler.INSTANCE) .subscribe(new Subscriber[] { ts }); ts.assertResult(1); } @SuppressWarnings("unchecked") @Test public void conditionalCancelAfterRequest1() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1) { @Override public void onNext(Integer t) { super.onNext(t); cancel(); onComplete(); } }; Flowable.range(1, 5) .parallel(1) .runOn(ImmediateThinScheduler.INSTANCE) .filter(Functions.alwaysTrue()) .subscribe(new Subscriber[] { ts }); ts.assertResult(1); }
Functions { public static <T> Predicate<T> predicateReverseFor(BooleanSupplier supplier) { return new BooleanSupplierPredicateReverse<T>(supplier); } private Functions(); static Function<Object[], R> toFunction(final BiFunction<? super T1, ? super T2, ? extends R> f); static Function<Object[], R> toFunction(final Function3<T1, T2, T3, R> f); static Function<Object[], R> toFunction(final Function4<T1, T2, T3, T4, R> f); static Function<Object[], R> toFunction(final Function5<T1, T2, T3, T4, T5, R> f); static Function<Object[], R> toFunction( final Function6<T1, T2, T3, T4, T5, T6, R> f); static Function<Object[], R> toFunction( final Function7<T1, T2, T3, T4, T5, T6, T7, R> f); static Function<Object[], R> toFunction( final Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> f); static Function<Object[], R> toFunction( final Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> f); @SuppressWarnings("unchecked") static Function<T, T> identity(); @SuppressWarnings("unchecked") static Consumer<T> emptyConsumer(); @SuppressWarnings("unchecked") static Predicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static Predicate<T> alwaysFalse(); @SuppressWarnings("unchecked") static Callable<T> nullSupplier(); @SuppressWarnings("unchecked") static Comparator<T> naturalOrder(); static Action futureAction(Future<?> future); static Callable<T> justCallable(T value); static Function<T, U> justFunction(U value); static Function<T, U> castFunction(Class<U> target); static Callable<List<T>> createArrayList(int capacity); static Predicate<T> equalsWith(T value); @SuppressWarnings({ "rawtypes", "unchecked" }) static Callable<Set<T>> createHashSet(); static Consumer<T> notificationOnNext(Consumer<? super Notification<T>> onNotification); static Consumer<Throwable> notificationOnError(Consumer<? super Notification<T>> onNotification); static Action notificationOnComplete(Consumer<? super Notification<T>> onNotification); static Consumer<T> actionConsumer(Action action); static Predicate<T> isInstanceOf(Class<U> clazz); static Predicate<T> predicateReverseFor(BooleanSupplier supplier); static Function<T, Timed<T>> timestampWith(TimeUnit unit, Scheduler scheduler); static BiConsumer<Map<K, T>, T> toMapKeySelector(final Function<? super T, ? extends K> keySelector); static BiConsumer<Map<K, V>, T> toMapKeyValueSelector(final Function<? super T, ? extends K> keySelector, final Function<? super T, ? extends V> valueSelector); static BiConsumer<Map<K, Collection<V>>, T> toMultimapKeyValueSelector( final Function<? super T, ? extends K> keySelector, final Function<? super T, ? extends V> valueSelector, final Function<? super K, ? extends Collection<? super V>> collectionFactory); @SuppressWarnings("unchecked") static Comparator<T> naturalComparator(); static Function<List<T>, List<T>> listSorter(final Comparator<? super T> comparator); static final Runnable EMPTY_RUNNABLE; static final Action EMPTY_ACTION; static final Consumer<Throwable> ERROR_CONSUMER; static final Consumer<Throwable> ON_ERROR_MISSING; static final LongConsumer EMPTY_LONG_CONSUMER; }
@Test public void booleanSupplierPredicateReverse() throws Exception { BooleanSupplier s = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return false; } }; assertTrue(Functions.predicateReverseFor(s).test(1)); s = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return true; } }; assertFalse(Functions.predicateReverseFor(s).test(1)); }
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); }
@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)); }
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); }
@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)); }
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); }
@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(); } }
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); }
@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(); } }
EndSubscriberHelper { public static String composeMessage(String consumer) { return "It is not allowed to subscribe with a(n) " + consumer + " multiple times. " + "Please create a fresh instance of " + consumer + " and subscribe that to the target source instead."; } private 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); }
@Test public void checkDoubleDefaultSubscriber() { Subscriber<Integer> consumer = new DefaultSubscriber<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; BooleanSubscription sub1 = new BooleanSubscription(); consumer.onSubscribe(sub1); assertFalse(sub1.isCancelled()); BooleanSubscription sub2 = new BooleanSubscription(); consumer.onSubscribe(sub2); assertFalse(sub1.isCancelled()); assertTrue(sub2.isCancelled()); TestCommonHelper.assertError(errors, 0, ProtocolViolationException.class); assertEquals(EndSubscriberHelper.composeMessage(consumer.getClass().getName()), errors.get(0).getMessage()); assertEquals(errors.toString(), 1, errors.size()); } @Test public void checkDoubleDefaultSubscriberNonAnonymous() { Subscriber<Integer> consumer = new EndDefaultSubscriber(); BooleanSubscription sub1 = new BooleanSubscription(); consumer.onSubscribe(sub1); assertFalse(sub1.isCancelled()); BooleanSubscription sub2 = new BooleanSubscription(); consumer.onSubscribe(sub2); assertFalse(sub1.isCancelled()); assertTrue(sub2.isCancelled()); TestCommonHelper.assertError(errors, 0, ProtocolViolationException.class); assertEquals(EndSubscriberHelper.composeMessage("io.reactivex.flowable.internal.utils.EndSubscriberHelperTest$EndDefaultSubscriber"), errors.get(0).getMessage()); assertEquals(errors.toString(), 1, errors.size()); } @Test public void checkDoubleDisposableSubscriber() { Subscriber<Integer> consumer = new DisposableSubscriber<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; BooleanSubscription sub1 = new BooleanSubscription(); consumer.onSubscribe(sub1); assertFalse(sub1.isCancelled()); BooleanSubscription sub2 = new BooleanSubscription(); consumer.onSubscribe(sub2); assertFalse(sub1.isCancelled()); assertTrue(sub2.isCancelled()); TestCommonHelper.assertError(errors, 0, ProtocolViolationException.class); assertEquals(EndSubscriberHelper.composeMessage(consumer.getClass().getName()), errors.get(0).getMessage()); assertEquals(errors.toString(), 1, errors.size()); } @Test public void checkDoubleResourceSubscriber() { Subscriber<Integer> consumer = new ResourceSubscriber<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }; BooleanSubscription sub1 = new BooleanSubscription(); consumer.onSubscribe(sub1); assertFalse(sub1.isCancelled()); BooleanSubscription sub2 = new BooleanSubscription(); consumer.onSubscribe(sub2); assertFalse(sub1.isCancelled()); assertTrue(sub2.isCancelled()); TestCommonHelper.assertError(errors, 0, ProtocolViolationException.class); assertEquals(EndSubscriberHelper.composeMessage(consumer.getClass().getName()), errors.get(0).getMessage()); assertEquals(errors.toString(), 1, errors.size()); }
Functions { public static <T1, T2, R> Function<Object[], R> toFunction(final BiFunction<? super T1, ? super T2, ? extends R> f) { ObjectHelper.requireNonNull(f, "f is null"); return new Array2Func<T1, T2, R>(f); } private Functions(); static Function<Object[], R> toFunction(final BiFunction<? super T1, ? super T2, ? extends R> f); static Function<Object[], R> toFunction(final Function3<T1, T2, T3, R> f); static Function<Object[], R> toFunction(final Function4<T1, T2, T3, T4, R> f); static Function<Object[], R> toFunction(final Function5<T1, T2, T3, T4, T5, R> f); static Function<Object[], R> toFunction( final Function6<T1, T2, T3, T4, T5, T6, R> f); static Function<Object[], R> toFunction( final Function7<T1, T2, T3, T4, T5, T6, T7, R> f); static Function<Object[], R> toFunction( final Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> f); static Function<Object[], R> toFunction( final Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> f); @SuppressWarnings("unchecked") static Function<T, T> identity(); @SuppressWarnings("unchecked") static Consumer<T> emptyConsumer(); @SuppressWarnings("unchecked") static Predicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static Predicate<T> alwaysFalse(); @SuppressWarnings("unchecked") static Callable<T> nullSupplier(); @SuppressWarnings("unchecked") static Comparator<T> naturalOrder(); static Action futureAction(Future<?> future); static Callable<T> justCallable(T value); static Function<T, U> justFunction(U value); static Function<T, U> castFunction(Class<U> target); static Callable<List<T>> createArrayList(int capacity); static Predicate<T> equalsWith(T value); @SuppressWarnings({ "rawtypes", "unchecked" }) static Callable<Set<T>> createHashSet(); static Consumer<T> notificationOnNext(Consumer<? super Notification<T>> onNotification); static Consumer<Throwable> notificationOnError(Consumer<? super Notification<T>> onNotification); static Action notificationOnComplete(Consumer<? super Notification<T>> onNotification); static Consumer<T> actionConsumer(Action action); static Predicate<T> isInstanceOf(Class<U> clazz); static Predicate<T> predicateReverseFor(BooleanSupplier supplier); static Function<T, Timed<T>> timestampWith(TimeUnit unit, Scheduler scheduler); static BiConsumer<Map<K, T>, T> toMapKeySelector(final Function<? super T, ? extends K> keySelector); static BiConsumer<Map<K, V>, T> toMapKeyValueSelector(final Function<? super T, ? extends K> keySelector, final Function<? super T, ? extends V> valueSelector); static BiConsumer<Map<K, Collection<V>>, T> toMultimapKeyValueSelector( final Function<? super T, ? extends K> keySelector, final Function<? super T, ? extends V> valueSelector, final Function<? super K, ? extends Collection<? super V>> collectionFactory); @SuppressWarnings("unchecked") static Comparator<T> naturalComparator(); static Function<List<T>, List<T>> listSorter(final Comparator<? super T> comparator); static final Runnable EMPTY_RUNNABLE; static final Action EMPTY_ACTION; static final Consumer<Throwable> ERROR_CONSUMER; static final Consumer<Throwable> ON_ERROR_MISSING; static final LongConsumer EMPTY_LONG_CONSUMER; }
@Test(expected = IllegalArgumentException.class) public void toFunction2() throws Exception { Functions.toFunction(new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) throws Exception { return null; } }).apply(new Object[20]); } @Test(expected = IllegalArgumentException.class) public void toFunction3() throws Exception { Functions.toFunction(new Function3<Integer, Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2, Integer t3) throws Exception { return null; } }).apply(new Object[20]); } @Test(expected = IllegalArgumentException.class) public void toFunction4() throws Exception { Functions.toFunction(new Function4<Integer, Integer, Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2, Integer t3, Integer t4) throws Exception { return null; } }).apply(new Object[20]); } @Test(expected = IllegalArgumentException.class) public void toFunction5() throws Exception { Functions.toFunction(new Function5<Integer, Integer, Integer, Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5) throws Exception { return null; } }).apply(new Object[20]); } @Test(expected = IllegalArgumentException.class) public void toFunction6() throws Exception { Functions.toFunction(new Function6<Integer, Integer, Integer, Integer, Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6) throws Exception { return null; } }).apply(new Object[20]); } @Test(expected = IllegalArgumentException.class) public void toFunction7() throws Exception { Functions.toFunction(new Function7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7) throws Exception { return null; } }).apply(new Object[20]); } @Test(expected = IllegalArgumentException.class) public void toFunction8() throws Exception { Functions.toFunction(new Function8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8) throws Exception { return null; } }).apply(new Object[20]); } @Test(expected = IllegalArgumentException.class) public void toFunction9() throws Exception { Functions.toFunction(new Function9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8, Integer t9) throws Exception { return null; } }).apply(new Object[20]); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test(expected = NullPointerException.class) public void biFunctionFail() throws Exception { BiFunction biFunction = null; Functions.toFunction(biFunction); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test(expected = NullPointerException.class) public void function3Fail() throws Exception { Function3 function3 = null; Functions.toFunction(function3); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test(expected = NullPointerException.class) public void function4Fail() throws Exception { Function4 function4 = null; Functions.toFunction(function4); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test(expected = NullPointerException.class) public void function5Fail() throws Exception { Function5 function5 = null; Functions.toFunction(function5); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test(expected = NullPointerException.class) public void function6Fail() throws Exception { Function6 function6 = null; Functions.toFunction(function6); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test(expected = NullPointerException.class) public void function7Fail() throws Exception { Function7 function7 = null; Functions.toFunction(function7); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test(expected = NullPointerException.class) public void function8Fail() throws Exception { Function8 function8 = null; Functions.toFunction(function8); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test(expected = NullPointerException.class) public void function9Fail() throws Exception { Function9 function9 = null; Functions.toFunction(function9); }