target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test(expected = UnsupportedOperationException.class) public void offer() { q.offer(1); } | @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } | BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } } | BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } } | BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } @Override final boolean offer(T e); @Override final boolean offer(T v1, T v2); } | BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } @Override final boolean offer(T e); @Override final boolean offer(T v1, T v2); } |
@Test(expected = UnsupportedOperationException.class) public void offer2() { q.offer(1, 2); } | @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } | BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } } | BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } } | BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } @Override final boolean offer(T e); @Override final boolean offer(T v1, T v2); } | BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } @Override final boolean offer(T e); @Override final boolean offer(T v1, T v2); } |
@Test public void onSubscribeThrows() { final List<Object> received = new ArrayList<Object>(); LambdaObserver<Object> o = new LambdaObserver<Object>(new Consumer<Object>() { @Override public void accept(Object v) throws Exception { received.add(v); } }, new Consumer<Throwable>() { @Override public void accept(Throwable... | @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... |
@Test public void onNextThrows() { final List<Object> received = new ArrayList<Object>(); LambdaObserver<Object> o = new LambdaObserver<Object>(new Consumer<Object>() { @Override public void accept(Object v) throws Exception { throw new TestException(); } }, new Consumer<Throwable>() { @Override public void accept(Thro... | @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... |
@Test public void onErrorThrows() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { final List<Object> received = new ArrayList<Object>(); LambdaObserver<Object> o = new LambdaObserver<Object>(new Consumer<Object>() { @Override public void accept(Object v) throws Exception { received.add(v); } }, n... | @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... |
@Test public void onCompleteThrows() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { final List<Object> received = new ArrayList<Object>(); LambdaObserver<Object> o = new LambdaObserver<Object>(new Consumer<Object>() { @Override public void accept(Object v) throws Exception { received.add(v); } }... | @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public boolean isDisposed() { return get() == DisposableHelper.DISPOSED; } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposa... |
@Test public void onNextThrowsCancelsUpstream() { PublishSubject<Integer> ps = PublishSubject.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 onNext(T t) { if (!isDisposed()) { try { onNext.accept(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); get().dispose(); onError(e); } } } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public void onNext(T t) { if (!isDisposed()) { try { onNext.accept(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); get().dispose(); onError(e); } } } } | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public void onNext(T t) { if (!isDisposed()) { try { onNext.accept(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); get().dispose(); onError(e); } } } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Thro... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public void onNext(T t) { if (!isDisposed()) { try { onNext.accept(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); get().dispose(); onError(e); } } } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Thro... | LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public void onNext(T t) { if (!isDisposed()) { try { onNext.accept(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); get().dispose(); onError(e); } } } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Thro... |
@Test public void offerDifferentSubscription() { TestObserver<Integer> ts = new TestObserver<Integer>(); ObserverFullArbiter<Integer> fa = new ObserverFullArbiter<Integer>(ts, null, 128); Disposable bs = Disposables.empty(); fa.queue.offer(bs, NotificationLite.next(1)); fa.drain(); ts.assertNoValues(); } | void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if (o == s) { if (NotificationLite.isDisposable(v)) { Disposable next =... | ObserverFullArbiter extends FullArbiterPad1 implements Disposable { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if ... | ObserverFullArbiter extends FullArbiterPad1 implements Disposable { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if ... | ObserverFullArbiter extends FullArbiterPad1 implements Disposable { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if ... | ObserverFullArbiter extends FullArbiterPad1 implements Disposable { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if ... |
@Test public void dontEnterDrain() { TestObserver<Integer> ts = new TestObserver<Integer>(); ObserverFullArbiter<Integer> fa = new ObserverFullArbiter<Integer>(ts, null, 128); fa.queue.offer(fa.s, NotificationLite.next(1)); fa.wip.getAndIncrement(); fa.drain(); ts.assertNoValues(); } | void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if (o == s) { if (NotificationLite.isDisposable(v)) { Disposable next =... | ObserverFullArbiter extends FullArbiterPad1 implements Disposable { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if ... | ObserverFullArbiter extends FullArbiterPad1 implements Disposable { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if ... | ObserverFullArbiter extends FullArbiterPad1 implements Disposable { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if ... | ObserverFullArbiter extends FullArbiterPad1 implements Disposable { void drain() { if (wip.getAndIncrement() != 0) { return; } int missed = 1; final SpscLinkedArrayQueue<Object> q = queue; final Observer<? super T> a = actual; for (;;) { for (;;) { Object o = q.poll(); if (o == null) { break; } Object v = q.poll(); if ... |
@Test public void disposeRace() { for (int i = 0; i < 500; i++) { final CompositeDisposable cd = new CompositeDisposable(); Runnable run = new Runnable() { @Override public void run() { cd.dispose(); } }; TestCommonHelper.race(run, run, Schedulers.io()); } } | @Override public void dispose() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } disposed = true; set = resources; resources = null; } dispose(set); } | CompositeDisposable implements Disposable, DisposableContainer { @Override public void dispose() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } disposed = true; set = resources; resources = null; } dispose(set); } } | CompositeDisposable implements Disposable, DisposableContainer { @Override public void dispose() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } disposed = true; set = resources; resources = null; } dispose(set); } CompositeDisposable(); CompositeDisposable(@Non... | CompositeDisposable implements Disposable, DisposableContainer { @Override public void dispose() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } disposed = true; set = resources; resources = null; } dispose(set); } CompositeDisposable(); CompositeDisposable(@Non... | CompositeDisposable implements Disposable, DisposableContainer { @Override public void dispose() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } disposed = true; set = resources; resources = null; } dispose(set); } CompositeDisposable(); CompositeDisposable(@Non... |
@Test public void onlyFirstShouldSubscribeAndLastUnsubscribe() { final AtomicInteger subscriptionCount = new AtomicInteger(); final AtomicInteger unsubscriptionCount = new AtomicInteger(); Observable<Integer> o = Observable.unsafeCreate(new ObservableSource<Integer>() { @Override public void subscribe(Observer<? super ... | private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } | ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } } | ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } ObservableRefCount(ConnectableObservable<T> source); } | ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } ObservableRefCount(ConnectableObservable<T> source); @Override void subscribeActual(final... | ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } ObservableRefCount(ConnectableObservable<T> source); @Override void subscribeActual(final... |
@Test public void noOpConnect() { final int[] calls = { 0 }; Observable<Integer> o = new ConnectableObservable<Integer>() { @Override public void connect(Consumer<? super Disposable> connection) { calls[0]++; } @Override protected void subscribeActual(Observer<? super Integer> observer) { observer.onSubscribe(Disposabl... | private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } | ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } } | ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } ObservableRefCount(ConnectableObservable<T> source); } | ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } ObservableRefCount(ConnectableObservable<T> source); @Override void subscribeActual(final... | ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } ObservableRefCount(ConnectableObservable<T> source); @Override void subscribeActual(final... |
@Test public void source() { Maybe<Integer> m = Maybe.just(1); Single<Integer> s = m.toSingle(); assertTrue(s.getClass().toString(), s instanceof HasUpstreamMaybeSource); assertSame(m, (((HasUpstreamMaybeSource<?>)s).source())); } | @Override public MaybeSource<T> source() { return source; } | MaybeToSingle extends Single<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } } | MaybeToSingle extends Single<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToSingle(MaybeSource<T> source, T defaultValue); } | MaybeToSingle extends Single<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToSingle(MaybeSource<T> source, T defaultValue); @Override MaybeSource<T> source(); } | MaybeToSingle extends Single<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToSingle(MaybeSource<T> source, T defaultValue); @Override MaybeSource<T> source(); } |
@Test public void testAsync() { Observable<Integer> source = Observable.range(1, 10000); for (int i = 0; i < 100; i++) { TestObserver<Integer> ts1 = new TestObserver<Integer>(); ObservableCache<Integer> cached = (ObservableCache<Integer>)ObservableCache.from(source); cached.observeOn(Schedulers.computation()).subscribe... | public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } | ObservableCache extends AbstractObservableWithUpstream<T, T> { public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } } | ObservableCache extends AbstractObservableWithUpstream<T, T> { public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } private ObservableCache(Observable<T> source, CacheState<T> state); } | ObservableCache extends AbstractObservableWithUpstream<T, T> { public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } private ObservableCache(Observable<T> source, CacheState<T> state); static Observable<T> from(Observable<T> source); static Observable<T> from(Observable<T> source, int... | ObservableCache extends AbstractObservableWithUpstream<T, T> { public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } private ObservableCache(Observable<T> source, CacheState<T> state); static Observable<T> from(Observable<T> source); static Observable<T> from(Observable<T> source, int... |
@Test public void testAsyncComeAndGo() { Observable<Long> source = Observable.interval(1, 1, TimeUnit.MILLISECONDS) .take(1000) .subscribeOn(Schedulers.io()); ObservableCache<Long> cached = (ObservableCache<Long>)ObservableCache.from(source); Observable<Long> output = cached.observeOn(Schedulers.computation()); List<Te... | public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } | ObservableCache extends AbstractObservableWithUpstream<T, T> { public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } } | ObservableCache extends AbstractObservableWithUpstream<T, T> { public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } private ObservableCache(Observable<T> source, CacheState<T> state); } | ObservableCache extends AbstractObservableWithUpstream<T, T> { public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } private ObservableCache(Observable<T> source, CacheState<T> state); static Observable<T> from(Observable<T> source); static Observable<T> from(Observable<T> source, int... | ObservableCache extends AbstractObservableWithUpstream<T, T> { public static <T> Observable<T> from(Observable<T> source) { return from(source, 16); } private ObservableCache(Observable<T> source, CacheState<T> state); static Observable<T> from(Observable<T> source); static Observable<T> from(Observable<T> source, int... |
@SuppressWarnings("unchecked") @Test public void hasSource() { assertSame(Maybe.empty(), ((HasUpstreamMaybeSource<Object>)(Maybe.empty().count())).source()); } | @Override public MaybeSource<T> source() { return source; } | MaybeCount extends Single<Long> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } } | MaybeCount extends Single<Long> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeCount(MaybeSource<T> source); } | MaybeCount extends Single<Long> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeCount(MaybeSource<T> source); @Override MaybeSource<T> source(); } | MaybeCount extends Single<Long> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeCount(MaybeSource<T> source); @Override MaybeSource<T> source(); } |
@Test public void tryScalarXMap() { TestObserver<Integer> ts = new TestObserver<Integer>(); assertTrue(ObservableScalarXMap.tryScalarXMapSubscribe(new CallablePublisher(), ts, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer f) throws Exception { return Obser... | @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catch (Throwable ex) { Exce... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... |
@Test public void emptyXMap() { TestObserver<Integer> ts = new TestObserver<Integer>(); assertTrue(ObservableScalarXMap.tryScalarXMapSubscribe(new EmptyCallablePublisher(), ts, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer f) throws Exception { return Obse... | @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catch (Throwable ex) { Exce... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... |
@Test public void mapperCrashes() { TestObserver<Integer> ts = new TestObserver<Integer>(); assertTrue(ObservableScalarXMap.tryScalarXMapSubscribe(new OneCallablePublisher(), ts, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer f) throws Exception { throw new... | @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catch (Throwable ex) { Exce... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... |
@Test public void mapperToJust() { TestObserver<Integer> ts = new TestObserver<Integer>(); assertTrue(ObservableScalarXMap.tryScalarXMapSubscribe(new OneCallablePublisher(), ts, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer f) throws Exception { return Obs... | @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catch (Throwable ex) { Exce... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... |
@Test public void addRace() { for (int i = 0; i < 500; i++) { final CompositeDisposable cd = new CompositeDisposable(); Runnable run = new Runnable() { @Override public void run() { cd.add(Disposables.empty()); } }; TestCommonHelper.race(run, run, Schedulers.io()); } } | @Override public boolean add(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "d is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(); resources = set; } set.add(d); return true; } } } d.dispose(); retur... | CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean add(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "d is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(); res... | CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean add(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "d is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(); res... | CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean add(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "d is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(); res... | CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean add(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "d is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(); res... |
@Test public void mapperToEmpty() { TestObserver<Integer> ts = new TestObserver<Integer>(); assertTrue(ObservableScalarXMap.tryScalarXMapSubscribe(new OneCallablePublisher(), ts, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer f) throws Exception { return Ob... | @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catch (Throwable ex) { Exce... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... |
@Test public void mapperToCrashingCallable() { TestObserver<Integer> ts = new TestObserver<Integer>(); assertTrue(ObservableScalarXMap.tryScalarXMapSubscribe(new OneCallablePublisher(), ts, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer f) throws Exception ... | @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catch (Throwable ex) { Exce... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... | ObservableScalarXMap { @SuppressWarnings("unchecked") public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper) { if (source instanceof Callable) { T t; try { t = ((Callable<T>)source).call(); } catc... |
@Test public void scalarMapToEmpty() { ObservableScalarXMap.scalarXMap(1, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) throws Exception { return Observable.empty(); } }) .test() .assertResult(); } | public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } | ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } } | ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } private ObservableScalarXMap(); } | ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } private ObservableScalarXMap(); @SuppressWarnings("unchecked") static boolean ... | ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } private ObservableScalarXMap(); @SuppressWarnings("unchecked") static boolean ... |
@Test public void scalarMapToCrashingCallable() { ObservableScalarXMap.scalarXMap(1, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) throws Exception { return new CallablePublisher(); } }) .test() .assertFailure(TestException.class); } | public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } | ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } } | ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } private ObservableScalarXMap(); } | ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } private ObservableScalarXMap(); @SuppressWarnings("unchecked") static boolean ... | ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } private ObservableScalarXMap(); @SuppressWarnings("unchecked") static boolean ... |
@Test public void testReplaySelector() { final Function<Integer, Integer> dbl = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { return t1 * 2; } }; Function<Observable<Integer>, Observable<Integer>> selector = new Function<Observable<Integer>, Observable<Integer>>() { @Override public Ob... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@Test public void testBufferedReplaySelector() { final Function<Integer, Integer> dbl = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { return t1 * 2; } }; Function<Observable<Integer>, Observable<Integer>> selector = new Function<Observable<Integer>, Observable<Integer>>() { @Override p... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@Test public void testWindowedReplaySelector() { final Function<Integer, Integer> dbl = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { return t1 * 2; } }; Function<Observable<Integer>, Observable<Integer>> selector = new Function<Observable<Integer>, Observable<Integer>>() { @Override p... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@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); Observer<Integer> spiedSubscriberBeforeConnect = TestHelper.mockObserver... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFactory.call(); ReplayObserver<T> u = new ReplayObserver<T>(buf); if (!current.compareAndSet(ps, u)) { continu... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... |
@SuppressWarnings("unchecked") @Test public void testIssue2191_SchedulerUnsubscribe() throws Exception { Consumer<Integer> sourceNext = mock(Consumer.class); Action sourceCompleted = mock(Action.class); Action sourceUnsubscribed = mock(Action.class); final TestScheduler mockScheduler = new TestScheduler(); Observer<Int... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFactory.call(); ReplayObserver<T> u = new ReplayObserver<T>(buf); if (!current.compareAndSet(ps, u)) { continu... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... |
@SuppressWarnings("unchecked") @Test public void testIssue2191_SchedulerUnsubscribeOnError() throws Exception { Consumer<Integer> sourceNext = mock(Consumer.class); Action sourceCompleted = mock(Action.class); Consumer<Throwable> sourceError = mock(Consumer.class); Action sourceUnsubscribed = mock(Action.class); final ... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFactory.call(); ReplayObserver<T> u = new ReplayObserver<T>(buf); if (!current.compareAndSet(ps, u)) { continu... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... |
@Test public void addAllRace() { for (int i = 0; i < 500; i++) { final CompositeDisposable cd = new CompositeDisposable(); Runnable run = new Runnable() { @Override public void run() { cd.addAll(Disposables.empty()); } }; TestCommonHelper.race(run, run, Schedulers.io()); } } | public boolean addAll(@NonNull Disposable... ds) { ObjectHelper.requireNonNull(ds, "ds is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(ds.length + 1); resources = set; } for (Disposable d : ds) { ObjectHelpe... | CompositeDisposable implements Disposable, DisposableContainer { public boolean addAll(@NonNull Disposable... ds) { ObjectHelper.requireNonNull(ds, "ds is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(ds.leng... | CompositeDisposable implements Disposable, DisposableContainer { public boolean addAll(@NonNull Disposable... ds) { ObjectHelper.requireNonNull(ds, "ds is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(ds.leng... | CompositeDisposable implements Disposable, DisposableContainer { public boolean addAll(@NonNull Disposable... ds) { ObjectHelper.requireNonNull(ds, "ds is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(ds.leng... | CompositeDisposable implements Disposable, DisposableContainer { public boolean addAll(@NonNull Disposable... ds) { ObjectHelper.requireNonNull(ds, "ds is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(ds.leng... |
@Test public void testAsync() { Observable<Integer> source = Observable.range(1, 10000); for (int i = 0; i < 100; i++) { TestObserver<Integer> ts1 = new TestObserver<Integer>(); Observable<Integer> cached = source.replay().autoConnect(); cached.observeOn(Schedulers.computation()).subscribe(ts1); ts1.awaitTerminalEvent(... | public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssembly(new Replay<T>(co, observable)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... |
@Test public void testAsyncComeAndGo() { Observable<Long> source = Observable.interval(1, 1, TimeUnit.MILLISECONDS) .take(1000) .subscribeOn(Schedulers.io()); Observable<Long> cached = source.replay().autoConnect(); Observable<Long> output = cached.observeOn(Schedulers.computation()); List<TestObserver<Long>> list = ne... | public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssembly(new Replay<T>(co, observable)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... |
@Test public void testNoMissingBackpressureException() { final int m = 4 * 1000 * 1000; Observable<Integer> firehose = Observable.unsafeCreate(new ObservableSource<Integer>() { @Override public void subscribe(Observer<? super Integer> t) { t.onSubscribe(Disposables.empty()); for (int i = 0; i < m; i++) { t.onNext(i); }... | public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssembly(new Replay<T>(co, observable)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) { final Observable<T> observable = co.observeOn(scheduler); return RxJavaObservablePlugins.onAssemb... |
@Test public void source() { Observable<Integer> source = Observable.range(1, 3); assertSame(source, (((HasUpstreamObservableSource<?>)source.replay())).source()); } | @Override public ObservableSource<T> source() { return source; } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public ObservableSource<T> source() { return source; } } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public ObservableSource<T> source() { return source; } private ObservableReplay(ObservableSource<T> onSubscribe, ObservableSource<T> source,
final AtomicReference<ReplayObser... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public ObservableSource<T> source() { return source; } private ObservableReplay(ObservableSource<T> onSubscribe, ObservableSource<T> source,
final AtomicReference<ReplayObser... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public ObservableSource<T> source() { return source; } private ObservableReplay(ObservableSource<T> onSubscribe, ObservableSource<T> source,
final AtomicReference<ReplayObser... |
@Test public void connectRace() { for (int i = 0; i < 500; i++) { final ConnectableObservable<Integer> co = Observable.range(1, 3).replay(); Runnable r = new Runnable() { @Override public void run() { co.connect(); } }; TestCommonHelper.race(r, r); } } | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFactory.call(); ReplayObserver<T> u = new ReplayObserver<T>(buf); if (!current.compareAndSet(ps, u)) { continu... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... |
@Test public void cancelOnArrival2() { ConnectableObservable<Integer> co = PublishSubject.<Integer>create() .replay(Integer.MAX_VALUE); co.test(); co .autoConnect() .test(true) .assertEmpty(); } | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@Test public void connectConsumerThrows() { ConnectableObservable<Integer> co = Observable.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.tes... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFactory.call(); ReplayObserver<T> u = new ReplayObserver<T>(buf); if (!current.compareAndSet(ps, u)) { continu... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; ReplayObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { ReplayBuffer<T> buf = bufferFact... |
@Test public void subscribeOnNextRace() { for (int i = 0; i < 500; i++) { final PublishSubject<Integer> ps = PublishSubject.create(); final ConnectableObservable<Integer> co = ps.replay(); final TestObserver<Integer> to1 = new TestObserver<Integer>(); Runnable r1 = new Runnable() { @Override public void run() { co.subs... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@Test public void reentrantOnNext() { final PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<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);... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@Test public void reentrantOnNextBound() { final PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<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.onN... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@Test public void runnableThrows() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { ScheduledDirectPeriodicTask task = new ScheduledDirectPeriodicTask(new Runnable() { @Override public void run() { throw new TestException(); } }); task.run(); TestCommonHelper.assertUndeliverable(errors, 0, TestExc... | @Override public void run() { runner = Thread.currentThread(); try { try { runnable.run(); } catch (Throwable ex) { lazySet(FINISHED); RxJavaCommonPlugins.onError(ex); } } finally { runner = null; } } | ScheduledDirectPeriodicTask extends AbstractDirectTask implements Runnable { @Override public void run() { runner = Thread.currentThread(); try { try { runnable.run(); } catch (Throwable ex) { lazySet(FINISHED); RxJavaCommonPlugins.onError(ex); } } finally { runner = null; } } } | ScheduledDirectPeriodicTask extends AbstractDirectTask implements Runnable { @Override public void run() { runner = Thread.currentThread(); try { try { runnable.run(); } catch (Throwable ex) { lazySet(FINISHED); RxJavaCommonPlugins.onError(ex); } } finally { runner = null; } } ScheduledDirectPeriodicTask(Runnable runna... | ScheduledDirectPeriodicTask extends AbstractDirectTask implements Runnable { @Override public void run() { runner = Thread.currentThread(); try { try { runnable.run(); } catch (Throwable ex) { lazySet(FINISHED); RxJavaCommonPlugins.onError(ex); } } finally { runner = null; } } ScheduledDirectPeriodicTask(Runnable runna... | ScheduledDirectPeriodicTask extends AbstractDirectTask implements Runnable { @Override public void run() { runner = Thread.currentThread(); try { try { runnable.run(); } catch (Throwable ex) { lazySet(FINISHED); RxJavaCommonPlugins.onError(ex); } } finally { runner = null; } } ScheduledDirectPeriodicTask(Runnable runna... |
@Test public void reentrantOnNextCancel() { final PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<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); ... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@Test public void reentrantOnNextCancelBounded() { final PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<Integer>() { @Override public void onNext(Integer t) { if (t == 1) { ps.onNext(2); cancel(); } super.onNext(t); } }; ps.replay(10).autoConnect().subscribe(to); ps.on... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSupplier<T>(bufferSize)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <T> ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize) { if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } return create(source, new ReplayBufferSuppli... |
@Test public void replaySelectorConnectableReturnsNull() { ObservableReplay.multicastSelector(Functions.justCallable((ConnectableObservable<Integer>)null), Functions.justFunction(Observable.just(1))) .test() .assertFailureAndMessage(NullPointerException.class, "The connectableFactory returned a null ConnectableObservab... | public static <U, R> Observable<R> multicastSelector( final Callable<? extends ConnectableObservable<U>> connectableFactory, final Function<? super Observable<U>, ? extends ObservableSource<R>> selector) { return RxJavaObservablePlugins.onAssembly(new MulticastReplay<R, U>(connectableFactory, selector)); } | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <U, R> Observable<R> multicastSelector( final Callable<? extends ConnectableObservable<U>> connectableFactory, final Function<? super Observable<U>, ? extends ObservableSource<R>> selector) { return R... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <U, R> Observable<R> multicastSelector( final Callable<? extends ConnectableObservable<U>> connectableFactory, final Function<? super Observable<U>, ? extends ObservableSource<R>> selector) { return R... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <U, R> Observable<R> multicastSelector( final Callable<? extends ConnectableObservable<U>> connectableFactory, final Function<? super Observable<U>, ? extends ObservableSource<R>> selector) { return R... | ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { public static <U, R> Observable<R> multicastSelector( final Callable<? extends ConnectableObservable<U>> connectableFactory, final Function<? super Observable<U>, ? extends ObservableSource<R>> selector) { return R... |
@Test public void source() { Single<Integer> c = Single.never(); assertSame(c, ((HasUpstreamSingleSource<?>)Maybe.fromSingle(c)).source()); } | @Override public SingleSource<T> source() { return source; } | MaybeFromSingle extends Maybe<T> implements HasUpstreamSingleSource<T> { @Override public SingleSource<T> source() { return source; } } | MaybeFromSingle extends Maybe<T> implements HasUpstreamSingleSource<T> { @Override public SingleSource<T> source() { return source; } MaybeFromSingle(SingleSource<T> source); } | MaybeFromSingle extends Maybe<T> implements HasUpstreamSingleSource<T> { @Override public SingleSource<T> source() { return source; } MaybeFromSingle(SingleSource<T> source); @Override SingleSource<T> source(); } | MaybeFromSingle extends Maybe<T> implements HasUpstreamSingleSource<T> { @Override public SingleSource<T> source() { return source; } MaybeFromSingle(SingleSource<T> source); @Override SingleSource<T> source(); } |
@SuppressWarnings("unchecked") @Test public void hasSource() { assertSame(Maybe.empty(), ((HasUpstreamMaybeSource<Object>)(Maybe.empty().contains(0))).source()); } | @Override public MaybeSource<T> source() { return source; } | MaybeContains extends Single<Boolean> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } } | MaybeContains extends Single<Boolean> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeContains(MaybeSource<T> source, Object value); } | MaybeContains extends Single<Boolean> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeContains(MaybeSource<T> source, Object value); @Override MaybeSource<T> source(); } | MaybeContains extends Single<Boolean> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeContains(MaybeSource<T> source, Object value); @Override MaybeSource<T> source(); } |
@Test public void testMostRecentNull() { assertEquals(null, Observable.<Void>never().blockingMostRecent(null).iterator().next()); } | @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... |
@Test public void testMostRecent() { Subject<String> s = PublishSubject.create(); Iterator<String> it = mostRecent(s, "default").iterator(); assertTrue(it.hasNext()); assertEquals("default", it.next()); assertEquals("default", it.next()); s.onNext("one"); assertTrue(it.hasNext()); assertEquals("one", it.next()); assert... | @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... |
@Test(expected = TestException.class) public void testMostRecentWithException() { Subject<String> s = PublishSubject.create(); Iterator<String> it = mostRecent(s, "default").iterator(); assertTrue(it.hasNext()); assertEquals("default", it.next()); assertEquals("default", it.next()); s.onError(new TestException()); asse... | @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... |
@Test(timeout = 1000) public void testSingleSourceManyIterators() { TestScheduler scheduler = new TestScheduler(); Observable<Long> source = Observable.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... | @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... |
@Test public void empty() { Iterator<Integer> it = Observable.<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) { } } | @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } } | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... | BlockingObservableMostRecent implements Iterable<T> { @Override public Iterator<T> iterator() { MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue); source.subscribe(mostRecentObserver); return mostRecentObserver.getIterable(); } BlockingObservableMostRecent(ObservableSource<T> source, T ... |
@Test public void dispose() { CompositeDisposable set = new CompositeDisposable(); ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set); set.add(run); assertFalse(run.isDisposed()); set.dispose(); assertTrue(run.isDisposed()); } | @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THREAD_INDEX) != Thread.currentThread()); } break; } } for (;;) { Object o = get(PARENT_INDEX); if (o == DONE |... | ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THRE... | ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THRE... | ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THRE... | ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THRE... |
@SuppressWarnings("unchecked") @Test public void upstream() { Maybe<Integer> source = Maybe.just(1); assertSame(source, ((HasUpstreamMaybeSource<Integer>)source.map(Functions.<Integer>identity())).source()); } | @Override public final MaybeSource<T> source() { return source; } | AbstractMaybeWithUpstream extends Maybe<R> implements HasUpstreamMaybeSource<T> { @Override public final MaybeSource<T> source() { return source; } } | AbstractMaybeWithUpstream extends Maybe<R> implements HasUpstreamMaybeSource<T> { @Override public final MaybeSource<T> source() { return source; } AbstractMaybeWithUpstream(MaybeSource<T> source); } | AbstractMaybeWithUpstream extends Maybe<R> implements HasUpstreamMaybeSource<T> { @Override public final MaybeSource<T> source() { return source; } AbstractMaybeWithUpstream(MaybeSource<T> source); @Override final MaybeSource<T> source(); } | AbstractMaybeWithUpstream extends Maybe<R> implements HasUpstreamMaybeSource<T> { @Override public final MaybeSource<T> source() { return source; } AbstractMaybeWithUpstream(MaybeSource<T> source); @Override final MaybeSource<T> source(); } |
@Test public void testNext() { Subject<String> obs = PublishSubject.create(); Iterator<String> it = next(obs).iterator(); fireOnNextInNewThread(obs, "one"); assertTrue(it.hasNext()); assertEquals("one", it.next()); fireOnNextInNewThread(obs, "two"); assertTrue(it.hasNext()); assertEquals("two", it.next()); fireOnNextIn... | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void testNextWithError() { Subject<String> obs = PublishSubject.create(); Iterator<String> it = next(obs).iterator(); fireOnNextInNewThread(obs, "one"); assertTrue(it.hasNext()); assertEquals("one", it.next()); fireOnErrorInNewThread(obs); try { it.hasNext(); fail("Expected an TestException"); } catch (Tes... | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void testNextWithEmpty() { Observable<String> obs = Observable.<String> empty().observeOn(Schedulers.newThread()); Iterator<String> it = next(obs).iterator(); assertFalse(it.hasNext()); try { it.next(); fail("At the end of an iterator should throw a NoSuchElementException"); } catch (NoSuchElementException... | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void testOnError() throws Throwable { Subject<String> obs = PublishSubject.create(); Iterator<String> it = next(obs).iterator(); obs.onError(new TestException()); try { it.hasNext(); fail("Expected an TestException"); } catch (TestException e) { } assertErrorAfterObservableFail(it); } | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void testOnErrorInNewThread() { Subject<String> obs = PublishSubject.create(); Iterator<String> it = next(obs).iterator(); fireOnErrorInNewThread(obs); try { it.hasNext(); fail("Expected an TestException"); } catch (TestException e) { } assertErrorAfterObservableFail(it); } | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void testNextWithOnlyUsingNextMethod() { Subject<String> obs = PublishSubject.create(); Iterator<String> it = next(obs).iterator(); fireOnNextInNewThread(obs, "one"); assertEquals("one", it.next()); fireOnNextInNewThread(obs, "two"); assertEquals("two", it.next()); obs.onComplete(); try { it.next(); fail("... | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void testNextWithCallingHasNextMultipleTimes() { Subject<String> obs = PublishSubject.create(); Iterator<String> it = next(obs).iterator(); fireOnNextInNewThread(obs, "one"); assertTrue(it.hasNext()); assertTrue(it.hasNext()); assertTrue(it.hasNext()); assertTrue(it.hasNext()); assertEquals("one", it.next(... | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@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 AtomicBoole... | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void testSingleSourceManyIterators() throws InterruptedException { Observable<Long> o = Observable.interval(250, TimeUnit.MILLISECONDS); PublishSubject<Integer> terminal = PublishSubject.create(); Observable<Long> source = o.takeUntil(terminal); Iterable<Long> iter = source.blockingNext(); for (int j = 0; ... | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void disposeRace() { for (int i = 0; i < 500; i++) { CompositeDisposable set = new CompositeDisposable(); final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set); set.add(run); Runnable r1 = new Runnable() { @Override public void run() { run.dispose(); } }; TestCommonHelper.race(... | @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THREAD_INDEX) != Thread.currentThread()); } break; } } for (;;) { Object o = get(PARENT_INDEX); if (o == DONE |... | ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THRE... | ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THRE... | ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THRE... | ScheduledRunnable extends AtomicReferenceArray<Object> implements Runnable, Callable<Object>, Disposable { @Override public void dispose() { for (;;) { Object o = get(FUTURE_INDEX); if (o == DONE || o == DISPOSED) { break; } if (compareAndSet(FUTURE_INDEX, o, DISPOSED)) { if (o != null) { ((Future<?>)o).cancel(get(THRE... |
@Test public void testSynchronousNext() { assertEquals(1, BehaviorSubject.createDefault(1).take(1).blockingSingle().intValue()); assertEquals(2, BehaviorSubject.createDefault(2).blockingIterable().iterator().next().intValue()); assertEquals(3, BehaviorSubject.createDefault(3).blockingNext().iterator().next().intValue()... | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void interrupt() { Iterator<Object> it = Observable.never().blockingNext().iterator(); try { Thread.currentThread().interrupt(); it.next(); } catch (RuntimeException ex) { assertTrue(ex.toString(), ex.getCause() instanceof InterruptedException); } } | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test(expected = UnsupportedOperationException.class) public void remove() { Observable.never().blockingNext().iterator().remove(); } | @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } | BlockingObservableNext implements Iterable<T> { @Override public Iterator<T> iterator() { NextObserver<T> nextObserver = new NextObserver<T>(); return new NextIterator<T>(source, nextObserver); } BlockingObservableNext(ObservableSource<T> source); @Override Iterator<T> iterator(); } |
@Test public void source() { Maybe<Integer> m = Maybe.just(1); assertSame(m, (((HasUpstreamMaybeSource<?>)m.toObservable()).source())); } | @Override public MaybeSource<T> source() { return source; } | MaybeToObservable extends Observable<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } } | MaybeToObservable extends Observable<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToObservable(MaybeSource<T> source); } | MaybeToObservable extends Observable<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToObservable(MaybeSource<T> source); @Override MaybeSource<T> source(); @SuppressWarnings({ "rawtypes", "unchecked" }) static Function<MaybeSource<T>, Observable<T>> instance()... | MaybeToObservable extends Observable<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToObservable(MaybeSource<T> source); @Override MaybeSource<T> source(); @SuppressWarnings({ "rawtypes", "unchecked" }) static Function<MaybeSource<T>, Observable<T>> instance()... |
@Test public void source() { Maybe<Integer> m = Maybe.just(1); assertSame(m, (((HasUpstreamMaybeSource<?>)m.isEmpty()).source())); } | @Override public MaybeSource<T> source() { return source; } | MaybeIsEmptySingle extends Single<Boolean> implements HasUpstreamMaybeSource<T>, FuseToMaybe<Boolean> { @Override public MaybeSource<T> source() { return source; } } | MaybeIsEmptySingle extends Single<Boolean> implements HasUpstreamMaybeSource<T>, FuseToMaybe<Boolean> { @Override public MaybeSource<T> source() { return source; } MaybeIsEmptySingle(MaybeSource<T> source); } | MaybeIsEmptySingle extends Single<Boolean> implements HasUpstreamMaybeSource<T>, FuseToMaybe<Boolean> { @Override public MaybeSource<T> source() { return source; } MaybeIsEmptySingle(MaybeSource<T> source); @Override MaybeSource<T> source(); @Override Maybe<Boolean> fuseToMaybe(); } | MaybeIsEmptySingle extends Single<Boolean> implements HasUpstreamMaybeSource<T>, FuseToMaybe<Boolean> { @Override public MaybeSource<T> source() { return source; } MaybeIsEmptySingle(MaybeSource<T> source); @Override MaybeSource<T> source(); @Override Maybe<Boolean> fuseToMaybe(); } |
@Test public void scalarCallable() { Maybe<Integer> m = Maybe.empty(); assertTrue(m.getClass().toString(), m instanceof ScalarCallable); assertNull(((ScalarCallable<?>)m).call()); } | @Override public Object call() { return null; } | MaybeEmpty extends Maybe<Object> implements ScalarCallable<Object> { @Override public Object call() { return null; } } | MaybeEmpty extends Maybe<Object> implements ScalarCallable<Object> { @Override public Object call() { return null; } } | MaybeEmpty extends Maybe<Object> implements ScalarCallable<Object> { @Override public Object call() { return null; } @Override Object call(); } | MaybeEmpty extends Maybe<Object> implements ScalarCallable<Object> { @Override public Object call() { return null; } @Override Object call(); static final MaybeEmpty INSTANCE; } |
@SuppressWarnings("unchecked") @Test public void callable() throws Exception { final int[] counter = { 0 }; Maybe<Integer> m = Maybe.fromCallable(new Callable<Integer>() { @Override public Integer call() throws Exception { counter[0]++; return 0; } }); assertTrue(m.getClass().toString(), m instanceof Callable); assertE... | @Override public T call() throws Exception { return callable.call(); } | MaybeFromCallable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { return callable.call(); } } | MaybeFromCallable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { return callable.call(); } MaybeFromCallable(Callable<? extends T> callable); } | MaybeFromCallable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { return callable.call(); } MaybeFromCallable(Callable<? extends T> callable); @Override T call(); } | MaybeFromCallable extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { return callable.call(); } MaybeFromCallable(Callable<? extends T> callable); @Override T call(); } |
@SuppressWarnings("unchecked") @Test public void callable() throws Exception { final int[] counter = { 0 }; Maybe<Void> m = Maybe.fromAction(new Action() { @Override public void run() throws Exception { counter[0]++; } }); assertTrue(m.getClass().toString(), m instanceof Callable); assertNull(((Callable<Void>)m).call()... | @Override public T call() throws Exception { action.run(); return null; } | MaybeFromAction extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { action.run(); return null; } } | MaybeFromAction extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { action.run(); return null; } MaybeFromAction(Action action); } | MaybeFromAction extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { action.run(); return null; } MaybeFromAction(Action action); @Override T call(); } | MaybeFromAction extends Maybe<T> implements Callable<T> { @Override public T call() throws Exception { action.run(); return null; } MaybeFromAction(Action action); @Override T call(); } |
@Test public void testPublish() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); ConnectableObservable<String> o = Observable.unsafeCreate(new ObservableSource<String>() { @Override public void subscribe(final Observer<? super String> observer) { observer.onSubscribe(Disposables.empty())... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void testBackpressureFastSlow() { ConnectableObservable<Integer> is = Observable.range(1, Observable.bufferSize() * 2).publish(); Observable<Integer> fast = is.observeOn(Schedulers.computation()) .doOnComplete(new Action() { @Override public void run() { System.out.println("^^^^^^^^^^^^^ completed FAST"); ... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test(timeout = 1000) public void runnableDisposedAsync() throws Exception { final Scheduler s = Schedulers.single(); Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE); while (!d.isDisposed()) { Thread.sleep(1); } } | @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executor.get().schedule(task, delay, unit);... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... |
@Test public void scheduleDirect() { final int[] count = { 0 }; TestScheduler scheduler = new TestScheduler(); scheduler.scheduleDirect(new Runnable() { @Override public void run() { count[0]++; } }, 100, TimeUnit.MILLISECONDS); assertEquals(0, count[0]); scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS); assertEqual... | @NonNull public Disposable scheduleDirect(@NonNull Runnable run) { return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); } | Scheduler { @NonNull public Disposable scheduleDirect(@NonNull Runnable run) { return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); } } | Scheduler { @NonNull public Disposable scheduleDirect(@NonNull Runnable run) { return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); } } | Scheduler { @NonNull public Disposable scheduleDirect(@NonNull Runnable run) { return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); } static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull... | Scheduler { @NonNull public Disposable scheduleDirect(@NonNull Runnable run) { return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); } static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull... |
@Test public void testTakeUntilWithPublishedStream() { Observable<Integer> xs = Observable.range(0, Observable.bufferSize() * 2); TestObserver<Integer> ts = new TestObserver<Integer>(); ConnectableObservable<Integer> xsp = xs.publish(); xsp.takeUntil(xsp.skipWhile(new Predicate<Integer>() { @Override public boolean tes... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void testConnectWithNoSubscriber() { TestScheduler scheduler = new TestScheduler(); ConnectableObservable<Long> co = Observable.interval(10, 10, TimeUnit.MILLISECONDS, scheduler).take(3).publish(); co.connect(); scheduler.advanceTimeBy(15, TimeUnit.MILLISECONDS); TestObserver<Long> to = new TestObserver<Lo... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void testSubscribeAfterDisconnectThenConnect() { ConnectableObservable<Integer> source = Observable.just(1).publish(); TestObserver<Integer> ts1 = new TestObserver<Integer>(); source.subscribe(ts1); Disposable s = source.connect(); ts1.assertValue(1); ts1.assertNoErrors(); ts1.assertTerminated(); TestObser... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void testNoSubscriberRetentionOnCompleted() { ObservablePublish<Integer> source = (ObservablePublish<Integer>)Observable.just(1).publish(); TestObserver<Integer> ts1 = new TestObserver<Integer>(); source.subscribe(ts1); ts1.assertNoValues(); ts1.assertNoErrors(); ts1.assertNotComplete(); source.connect(); ... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void testNonNullConnection() { ConnectableObservable<Object> source = Observable.never().publish(); assertNotNull(source.connect()); assertNotNull(source.connect()); } | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void testNoDisconnectSomeoneElse() { ConnectableObservable<Object> source = Observable.never().publish(); Disposable s1 = source.connect(); Disposable s2 = source.connect(); s1.dispose(); Disposable s3 = source.connect(); s2.dispose(); assertTrue(checkPublishDisposed(s1)); assertTrue(checkPublishDisposed(s... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void testConnectIsIdempotent() { final AtomicInteger calls = new AtomicInteger(); Observable<Integer> source = Observable.unsafeCreate(new ObservableSource<Integer>() { @Override public void subscribe(Observer<? super Integer> t) { t.onSubscribe(Disposables.empty()); calls.getAndIncrement(); } }); Connecta... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void testObserveOn() { ConnectableObservable<Integer> co = Observable.range(0, 1000).publish(); Observable<Integer> obs = co.observeOn(Schedulers.computation()); for (int i = 0; i < 1000; i++) { for (int j = 1; j < 6; j++) { List<TestObserver<Integer>> tss = new ArrayList<TestObserver<Integer>>(); for (int... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void preNextConnect() { for (int i = 0; i < 500; i++) { final ConnectableObservable<Integer> co = Observable.<Integer>empty().publish(); co.connect(); Runnable r1 = new Runnable() { @Override public void run() { co.test(); } }; TestCommonHelper.race(r1, r1); } } | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void connectRace() { for (int i = 0; i < 500; i++) { final ConnectableObservable<Integer> co = Observable.<Integer>empty().publish(); Runnable r1 = new Runnable() { @Override public void run() { co.connect(); } }; TestCommonHelper.race(r1, r1); } } | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test(timeout = 1000) public void runnableDisposedAsyncCrash() throws Exception { final Scheduler s = Schedulers.single(); Disposable d = s.scheduleDirect(new Runnable() { @Override public void run() { throw new IllegalStateException(); } }); while (!d.isDisposed()) { Thread.sleep(1); } } | @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executor.get().schedule(task, delay, unit);... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... |
@Test public void source() { Observable<Integer> o = Observable.never(); assertSame(o, (((HasUpstreamObservableSource<?>)o.publish()).source())); } | @Override public ObservableSource<T> source() { return source; } | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public ObservableSource<T> source() { return source; } } | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public ObservableSource<T> source() { return source; } private ObservablePublish(ObservableSource<T> onSubscribe, ObservableSource<T> source,
final AtomicReference<PublishObserver<T>> ... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public ObservableSource<T> source() { return source; } private ObservablePublish(ObservableSource<T> onSubscribe, ObservableSource<T> source,
final AtomicReference<PublishObserver<T>> ... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public ObservableSource<T> source() { return source; } private ObservablePublish(ObservableSource<T> onSubscribe, ObservableSource<T> source,
final AtomicReference<PublishObserver<T>> ... |
@Test public void connectThrows() { ConnectableObservable<Integer> co = Observable.<Integer>empty().publish(); try { co.connect(new Consumer<Disposable>() { @Override public void accept(Disposable s) throws Exception { throw new TestException(); } }); } catch (TestException ex) { } } | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void empty() { ConnectableObservable<Integer> co = Observable.<Integer>empty().publish(); co.connect(); } | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void take() { ConnectableObservable<Integer> co = Observable.range(1, 2).publish(); TestObserver<Integer> to = co.take(1).test(); co.connect(); to.assertResult(1); } | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void nextCancelRace() { for (int i = 0; i < 500; i++) { final PublishSubject<Integer> ps = PublishSubject.create(); final ConnectableObservable<Integer> co = ps.publish(); final TestObserver<Integer> to = co.test(); Runnable r1 = new Runnable() { @Override public void run() { ps.onNext(1); } }; Runnable r2... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T>(curr); return RxJavaObservablePlugins.onAssembly(new ObservablePublish<T>(onSubscribe, source... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... |
@Test public void noErrorLoss() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { ConnectableObservable<Object> co = Observable.error(new TestException()).publish(); co.connect(); TestCommonHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaCommonPlugins.reset(); } } | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@Test public void selectorDisconnectsIndependentSource() { PublishSubject<Integer> ps = PublishSubject.create(); ps.publish(new Function<Observable<Integer>, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Observable<Integer> v) throws Exception { return Observable.range(1, 2); } }) .tes... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T>(curr); return RxJavaObservablePlugins.onAssembly(new ObservablePublish<T>(onSubscribe, source... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... |
@Test public void selectorInnerError() { PublishSubject<Integer> ps = PublishSubject.create(); ps.publish(new Function<Observable<Integer>, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Observable<Integer> v) throws Exception { return Observable.error(new TestException()); } }) .test()... | public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T>(curr); return RxJavaObservablePlugins.onAssembly(new ObservablePublish<T>(onSubscribe, source... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { public static <T> ConnectableObservable<T> create(ObservableSource<T> source) { final AtomicReference<PublishObserver<T>> curr = new AtomicReference<PublishObserver<T>>(); ObservableSource<T> onSubscribe = new PublishSource<T... |
@Test public void delayedUpstreamOnSubscribe() { final Observer<?>[] sub = { null }; new Observable<Integer>() { @Override protected void subscribeActual(Observer<? super Integer> s) { sub[0] = s; } } .publish() .connect() .dispose(); Disposable bs = Disposables.empty(); sub[0].onSubscribe(bs); assertTrue(bs.isDisposed... | @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver<T>(current); if (!current.compareAndSet(ps, u)) { continue; } ps = u; } doConnect = !ps.should... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... | ObservablePublish extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> { @Override public void connect(Consumer<? super Disposable> connection) { boolean doConnect; PublishObserver<T> ps; for (;;) { ps = current.get(); if (ps == null || ps.isDisposed()) { PublishObserver<T> u = new PublishObserver... |
@SuppressWarnings("unchecked") @Test public void source() { Observable<Integer> o = Observable.just(1); assertSame(o, ((HasUpstreamObservableSource<Integer>)o.map(Functions.<Integer>identity())).source()); } | @Override public final ObservableSource<T> source() { return source; } | AbstractObservableWithUpstream extends Observable<U> implements HasUpstreamObservableSource<T> { @Override public final ObservableSource<T> source() { return source; } } | AbstractObservableWithUpstream extends Observable<U> implements HasUpstreamObservableSource<T> { @Override public final ObservableSource<T> source() { return source; } AbstractObservableWithUpstream(ObservableSource<T> source); } | AbstractObservableWithUpstream extends Observable<U> implements HasUpstreamObservableSource<T> { @Override public final ObservableSource<T> source() { return source; } AbstractObservableWithUpstream(ObservableSource<T> source); @Override final ObservableSource<T> source(); } | AbstractObservableWithUpstream extends Observable<U> implements HasUpstreamObservableSource<T> { @Override public final ObservableSource<T> source() { return source; } AbstractObservableWithUpstream(ObservableSource<T> source); @Override final ObservableSource<T> source(); } |
@Test(timeout = 1000) public void runnableDisposedAsyncTimed() throws Exception { final Scheduler s = Schedulers.single(); Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MILLISECONDS); while (!d.isDisposed()) { Thread.sleep(1); } } | @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executor.get().schedule(task, delay, unit);... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... | SingleScheduler extends Scheduler { @NonNull @Override public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaCommonPlugins.onSchedule(run)); try { Future<?> f; if (delay <= 0L) { f = executor.get().submit(task); } else { f = executo... |
@Test public void testObservableFromIterable() { Observable<String> o = Observable.fromIterable(Arrays.<String> asList("one", "two", "three")); Observer<String> observer = TestHelper.mockObserver(); o.subscribe(observer); verify(observer, times(1)).onNext("one"); verify(observer, times(1)).onNext("two"); verify(observe... | public ObservableFromIterable(Iterable<? extends T> source) { this.source = source; } | ObservableFromIterable extends Observable<T> { public ObservableFromIterable(Iterable<? extends T> source) { this.source = source; } } | ObservableFromIterable extends Observable<T> { public ObservableFromIterable(Iterable<? extends T> source) { this.source = source; } ObservableFromIterable(Iterable<? extends T> source); } | ObservableFromIterable extends Observable<T> { public ObservableFromIterable(Iterable<? extends T> source) { this.source = source; } ObservableFromIterable(Iterable<? extends T> source); @Override void subscribeActual(Observer<? super T> s); } | ObservableFromIterable extends Observable<T> { public ObservableFromIterable(Iterable<? extends T> source) { this.source = source; } ObservableFromIterable(Iterable<? extends T> source); @Override void subscribeActual(Observer<? super T> s); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.