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 = NullPointerException.class) public void nullOnTerminate() { UnicastSubject.create(5, null); } | @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... |
@Test(expected = IllegalArgumentException.class) public void negativeCapacityHint() { UnicastSubject.create(-1); } | @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... |
@Test(expected = IllegalArgumentException.class) public void zeroCapacityHint() { UnicastSubject.create(0); } | @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... |
@Test public void rejectSyncFusion() { UnicastSubject<Object> p = UnicastSubject.create(); TestObserver<Object> ts = ObserverFusion.newTest(QueueDisposable.SYNC); p.subscribe(ts); ObserverFusion.assertFusion(ts, QueueDisposable.NONE); } | @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... |
@Test public void cancelOnArrival() { UnicastSubject.create() .test(true) .assertEmpty(); } | @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } } | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... | UnicastSubject extends Subject<T> { @CheckReturnValue public static <T> UnicastSubject<T> create() { return new UnicastSubject<T>(bufferSize(), true); } UnicastSubject(int capacityHint, boolean delayError); UnicastSubject(int capacityHint, Runnable onTerminate); UnicastSubject(int capacityHint, Runnable onTerminate... |
@Test public void cancelRace() { AsyncSubject<Object> p = AsyncSubject.create(); for (int i = 0; i < 500; i++) { final TestObserver<Object> ts1 = p.test(); final TestObserver<Object> ts2 = p.test(); Runnable r1 = new Runnable() { @Override public void run() { ts1.cancel(); } }; Runnable r2 = new Runnable() { @Override ... | @CheckReturnValue public static <T> AsyncSubject<T> create() { return new AsyncSubject<T>(); } | AsyncSubject extends Subject<T> { @CheckReturnValue public static <T> AsyncSubject<T> create() { return new AsyncSubject<T>(); } } | AsyncSubject extends Subject<T> { @CheckReturnValue public static <T> AsyncSubject<T> create() { return new AsyncSubject<T>(); } @SuppressWarnings("unchecked") AsyncSubject(); } | AsyncSubject extends Subject<T> { @CheckReturnValue public static <T> AsyncSubject<T> create() { return new AsyncSubject<T>(); } @SuppressWarnings("unchecked") AsyncSubject(); @CheckReturnValue static AsyncSubject<T> create(); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @SuppressWarnings("unc... | AsyncSubject extends Subject<T> { @CheckReturnValue public static <T> AsyncSubject<T> create() { return new AsyncSubject<T>(); } @SuppressWarnings("unchecked") AsyncSubject(); @CheckReturnValue static AsyncSubject<T> create(); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @SuppressWarnings("unc... |
@Test public void cancelOnArrival() { CompletableSubject.create() .test(true) .assertEmpty(); } | @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... |
@Test public void cancelOnArrival2() { CompletableSubject cs = CompletableSubject.create(); cs.test(); cs .test(true) .assertEmpty(); } | @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... |
@Test public void dispose() { TestHelper.checkDisposed(CompletableSubject.create()); } | @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... |
@Test public void timedRunnableToString() { TimedRunnable r = new TimedRunnable((TestWorker) new TestScheduler().createWorker(), 5, new Runnable() { @Override public void run() { } @Override public String toString() { return "Runnable"; } }, 1); assertEquals("TimedRunnable(time = 5, run = Runnable)", r.toString()); } | @NonNull public abstract Worker createWorker(); | Scheduler { @NonNull public abstract Worker createWorker(); } | Scheduler { @NonNull public abstract Worker createWorker(); } | Scheduler { @NonNull public abstract Worker createWorker(); static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull Runnable run); @NonNull Disposable scheduleDirect(@NonNull Runnable run, l... | Scheduler { @NonNull public abstract Worker createWorker(); static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull Runnable run); @NonNull Disposable scheduleDirect(@NonNull Runnable run, l... |
@Test public void disposeTwice() { CompletableSubject.create() .subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { assertFalse(d.isDisposed()); d.dispose(); d.dispose(); assertTrue(d.isDisposed()); } @Override public void onError(Throwable e) { } @Override public void onComplete() {... | @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... |
@Test public void addRemoveRace() { for (int i = 0; i < 500; i++) { final CompletableSubject cs = CompletableSubject.create(); final TestObserver<Void> to = cs.test(); Runnable r1 = new Runnable() { @Override public void run() { cs.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { to.cancel(); }... | @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); } | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... | CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable ... |
@Test public void cancelOnArrival() { SingleSubject.create() .test(true) .assertEmpty(); } | @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... |
@Test public void cancelOnArrival2() { SingleSubject<Integer> ss = SingleSubject.create(); ss.test(); ss .test(true) .assertEmpty(); } | @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... |
@Test public void dispose() { TestHelper.checkDisposed(SingleSubject.create()); } | @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... |
@Test public void disposeTwice() { SingleSubject.create() .subscribe(new SingleObserver<Object>() { @Override public void onSubscribe(Disposable d) { assertFalse(d.isDisposed()); d.dispose(); d.dispose(); assertTrue(d.isDisposed()); } @Override public void onSuccess(Object value) { } @Override public void onError(Throw... | @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... |
@Test public void addRemoveRace() { for (int i = 0; i < 500; i++) { final SingleSubject<Integer> ss = SingleSubject.create(); final TestObserver<Integer> to = ss.test(); Runnable r1 = new Runnable() { @Override public void run() { ss.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { to.cancel();... | @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); } | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... | SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Dispo... |
@Test public void testGetValues() { ReplaySubject<Object> rs = ReplaySubject.create(); Object[] expected = new Object[10]; for (int i = 0; i < expected.length; i++) { expected[i] = i; rs.onNext(i); assertArrayEquals(Arrays.copyOf(expected, i + 1), rs.getValues()); } rs.onComplete(); assertArrayEquals(expected, rs.getVa... | public Object[] getValues() { @SuppressWarnings("unchecked") T[] a = (T[])EMPTY_ARRAY; T[] b = getValues(a); if (b == EMPTY_ARRAY) { return new Object[0]; } return b; } | ReplaySubject extends Subject<T> { public Object[] getValues() { @SuppressWarnings("unchecked") T[] a = (T[])EMPTY_ARRAY; T[] b = getValues(a); if (b == EMPTY_ARRAY) { return new Object[0]; } return b; } } | ReplaySubject extends Subject<T> { public Object[] getValues() { @SuppressWarnings("unchecked") T[] a = (T[])EMPTY_ARRAY; T[] b = getValues(a); if (b == EMPTY_ARRAY) { return new Object[0]; } return b; } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); } | ReplaySubject extends Subject<T> { public Object[] getValues() { @SuppressWarnings("unchecked") T[] a = (T[])EMPTY_ARRAY; T[] b = getValues(a); if (b == EMPTY_ARRAY) { return new Object[0]; } return b; } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> cre... | ReplaySubject extends Subject<T> { public Object[] getValues() { @SuppressWarnings("unchecked") T[] a = (T[])EMPTY_ARRAY; T[] b = getValues(a); if (b == EMPTY_ARRAY) { return new Object[0]; } return b; } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> cre... |
@Test public void createWithSizeInvalidCapacity() { try { ReplaySubject.createWithSize(-99); fail("Didn't throw IllegalArgumentException"); } catch (IllegalArgumentException ex) { assertEquals("maxSize > 0 required but it was -99", ex.getMessage()); } } | @CheckReturnValue public static <T> ReplaySubject<T> createWithSize(int maxSize) { return new ReplaySubject<T>(new SizeBoundReplayBuffer<T>(maxSize)); } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithSize(int maxSize) { return new ReplaySubject<T>(new SizeBoundReplayBuffer<T>(maxSize)); } } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithSize(int maxSize) { return new ReplaySubject<T>(new SizeBoundReplayBuffer<T>(maxSize)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithSize(int maxSize) { return new ReplaySubject<T>(new SizeBoundReplayBuffer<T>(maxSize)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckRet... | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithSize(int maxSize) { return new ReplaySubject<T>(new SizeBoundReplayBuffer<T>(maxSize)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckRet... |
@Test public void createWithTimeAndSizeInvalidCapacity() { try { ReplaySubject.createWithTimeAndSize(1, TimeUnit.DAYS, Schedulers.computation(), -99); fail("Didn't throw IllegalArgumentException"); } catch (IllegalArgumentException ex) { assertEquals("maxSize > 0 required but it was -99", ex.getMessage()); } } | @CheckReturnValue public static <T> ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize) { return new ReplaySubject<T>(new SizeAndTimeBoundReplayBuffer<T>(maxSize, maxAge, unit, scheduler)); } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize) { return new ReplaySubject<T>(new SizeAndTimeBoundReplayBuffer<T>(maxSize, maxAge, unit, scheduler)); } } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize) { return new ReplaySubject<T>(new SizeAndTimeBoundReplayBuffer<T>(maxSize, maxAge, unit, scheduler)); } @SuppressWarnings("unchecked") ReplaySubjec... | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize) { return new ReplaySubject<T>(new SizeAndTimeBoundReplayBuffer<T>(maxSize, maxAge, unit, scheduler)); } @SuppressWarnings("unchecked") ReplaySubjec... | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize) { return new ReplaySubject<T>(new SizeAndTimeBoundReplayBuffer<T>(maxSize, maxAge, unit, scheduler)); } @SuppressWarnings("unchecked") ReplaySubjec... |
@Test public void workerDisposed() { TestScheduler scheduler = new TestScheduler(); Worker w = scheduler.createWorker(); w.dispose(); assertTrue(w.isDisposed()); } | @NonNull public abstract Worker createWorker(); | Scheduler { @NonNull public abstract Worker createWorker(); } | Scheduler { @NonNull public abstract Worker createWorker(); } | Scheduler { @NonNull public abstract Worker createWorker(); static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull Runnable run); @NonNull Disposable scheduleDirect(@NonNull Runnable run, l... | Scheduler { @NonNull public abstract Worker createWorker(); static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull Runnable run); @NonNull Disposable scheduleDirect(@NonNull Runnable run, l... |
@Test public void hasObservers() { ReplaySubject<Integer> rp = ReplaySubject.create(); assertFalse(rp.hasObservers()); TestObserver<Integer> ts = rp.test(); assertTrue(rp.hasObservers()); ts.cancel(); assertFalse(rp.hasObservers()); } | @Override public boolean hasObservers() { return observers.get().length != 0; } | ReplaySubject extends Subject<T> { @Override public boolean hasObservers() { return observers.get().length != 0; } } | ReplaySubject extends Subject<T> { @Override public boolean hasObservers() { return observers.get().length != 0; } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); } | ReplaySubject extends Subject<T> { @Override public boolean hasObservers() { return observers.get().length != 0; } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySubject<T> create(int capacityHint); @CheckReturnVa... | ReplaySubject extends Subject<T> { @Override public boolean hasObservers() { return observers.get().length != 0; } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySubject<T> create(int capacityHint); @CheckReturnVa... |
@Test public void subscribeCancelRace() { for (int i = 0; i < 500; i++) { final TestObserver<Integer> ts = new TestObserver<Integer>(); final ReplaySubject<Integer> rp = ReplaySubject.create(); Runnable r1 = new Runnable() { @Override public void run() { rp.subscribe(ts); } }; Runnable r2 = new Runnable() { @Override p... | @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySu... | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySu... |
@Test public void subscribeRace() { for (int i = 0; i < 500; i++) { final ReplaySubject<Integer> rp = ReplaySubject.create(); Runnable r1 = new Runnable() { @Override public void run() { rp.test(); } }; TestCommonHelper.race(r1, r1, Schedulers.single()); } } | @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); } | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySu... | ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySu... |
@Test public void addRemoveRance() throws Exception { for (int i = 0; i < 100; i++) { final PublishSubject<Integer> pp = PublishSubject.create(); final TestObserver<Integer> ts = pp.test(); Runnable r1 = new Runnable() { @Override public void run() { pp.subscribe(); } }; Runnable r2 = new Runnable() { @Override public ... | @CheckReturnValue public static <T> PublishSubject<T> create() { return new PublishSubject<T>(); } | PublishSubject extends Subject<T> { @CheckReturnValue public static <T> PublishSubject<T> create() { return new PublishSubject<T>(); } } | PublishSubject extends Subject<T> { @CheckReturnValue public static <T> PublishSubject<T> create() { return new PublishSubject<T>(); } @SuppressWarnings("unchecked") PublishSubject(); } | PublishSubject extends Subject<T> { @CheckReturnValue public static <T> PublishSubject<T> create() { return new PublishSubject<T>(); } @SuppressWarnings("unchecked") PublishSubject(); @CheckReturnValue static PublishSubject<T> create(); @Override void subscribeActual(Observer<? super T> t); @Override void onSubscribe(... | PublishSubject extends Subject<T> { @CheckReturnValue public static <T> PublishSubject<T> create() { return new PublishSubject<T>(); } @SuppressWarnings("unchecked") PublishSubject(); @CheckReturnValue static PublishSubject<T> create(); @Override void subscribeActual(Observer<? super T> t); @Override void onSubscribe(... |
@Test public void cancelOnArrival() { MaybeSubject.create() .test(true) .assertEmpty(); } | @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... |
@Test public void cancelOnArrival2() { MaybeSubject<Integer> ms = MaybeSubject.create(); ms.test(); ms .test(true) .assertEmpty(); } | @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... |
@Test public void dispose() { TestHelper.checkDisposed(MaybeSubject.create()); } | @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... |
@Test public void disposeTwice() { MaybeSubject.create() .subscribe(new MaybeObserver<Object>() { @Override public void onSubscribe(Disposable d) { assertFalse(d.isDisposed()); d.dispose(); d.dispose(); assertTrue(d.isDisposed()); } @Override public void onSuccess(Object value) { } @Override public void onError(Throwab... | @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... |
@Test public void addRemoveRace() { for (int i = 0; i < 500; i++) { final MaybeSubject<Integer> ms = MaybeSubject.create(); final TestObserver<Integer> to = ms.test(); Runnable r1 = new Runnable() { @Override public void run() { ms.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { to.cancel(); }... | @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); } | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... | MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unche... |
@Test public void fromObservableMany() { Observable.range(1, 2) .singleElement() .test() .assertFailure(IllegalArgumentException.class); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSource<... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSource<... |
@Test public void hashCodeOf() { Timed<Integer> t1 = new Timed<Integer>(1, 5, TimeUnit.SECONDS); assertEquals(TimeUnit.SECONDS.hashCode() + 31 * (5 + 31 * 1), t1.hashCode()); Timed<Integer> t2 = new Timed<Integer>(null, 5, TimeUnit.SECONDS); assertEquals(TimeUnit.SECONDS.hashCode() + 31 * (5 + 31 * 0), t2.hashCode()); ... | @Override public int hashCode() { int h = value != null ? value.hashCode() : 0; h = h * 31 + (int)((time >>> 31) ^ time); h = h * 31 + unit.hashCode(); return h; } | Timed { @Override public int hashCode() { int h = value != null ? value.hashCode() : 0; h = h * 31 + (int)((time >>> 31) ^ time); h = h * 31 + unit.hashCode(); return h; } } | Timed { @Override public int hashCode() { int h = value != null ? value.hashCode() : 0; h = h * 31 + (int)((time >>> 31) ^ time); h = h * 31 + unit.hashCode(); return h; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); } | Timed { @Override public int hashCode() { int h = value != null ? value.hashCode() : 0; h = h * 31 + (int)((time >>> 31) ^ time); h = h * 31 + unit.hashCode(); return h; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNull TimeUnit unit(); long time(); long time(@NonNull TimeUnit u... | Timed { @Override public int hashCode() { int h = value != null ? value.hashCode() : 0; h = h * 31 + (int)((time >>> 31) ^ time); h = h * 31 + unit.hashCode(); return h; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNull TimeUnit unit(); long time(); long time(@NonNull TimeUnit u... |
@Test public void just() { Maybe.just(1) .test() .assertResult(1); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) stati... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) stati... |
@Test(expected = NullPointerException.class) public void justNull() { Maybe.just(null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) stati... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> just(T item) { ObjectHelper.requireNonNull(item, "item is null"); return RxJavaObservablePlugins.onAssembly(new MaybeJust<T>(item)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) stati... |
@Test public void empty() { Maybe.empty() .test() .assertResult(); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(fin... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(fin... |
@Test public void never() { Maybe.never() .test() .assertSubscribed() .assertNoValues() .assertNoErrors() .assertNotComplete(); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(fin... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(fin... |
@Test(expected = NullPointerException.class) public void errorNull() { Maybe.error((Throwable)null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } @CheckReturnValue @SchedulerSuppor... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } @CheckReturnValue @SchedulerSuppor... |
@Test(expected = NullPointerException.class) public void errorCallableNull() { Maybe.error((Callable<Throwable>)null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } @CheckReturnValue @SchedulerSuppor... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } @CheckReturnValue @SchedulerSuppor... |
@Test public void error() { Maybe.error(new TestException()) .test() .assertFailure(TestException.class); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } @CheckReturnValue @SchedulerSuppor... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> error(Throwable exception) { ObjectHelper.requireNonNull(exception, "exception is null"); return RxJavaObservablePlugins.onAssembly(new MaybeError<T>(exception)); } @CheckReturnValue @SchedulerSuppor... |
@Test(expected = NullPointerException.class) public void wrapNull() { Maybe.wrap(null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> wrap(MaybeSource<T> source) { if (source instanceof Maybe) { return RxJavaObservablePlugins.onAssembly((Maybe<T>)source); } ObjectHelper.requireNonNull(source, "onSubscribe is null"); return RxJavaObservablePlugins.onAssembly(new Mayb... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> wrap(MaybeSource<T> source) { if (source instanceof Maybe) { return RxJavaObservablePlugins.onAssembly((Maybe<T>)source); } ObjectHelper.requireNonNull(source, "onSubscribe is null"); return RxJavaObs... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> wrap(MaybeSource<T> source) { if (source instanceof Maybe) { return RxJavaObservablePlugins.onAssembly((Maybe<T>)source); } ObjectHelper.requireNonNull(source, "onSubscribe is null"); return RxJavaObs... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> wrap(MaybeSource<T> source) { if (source instanceof Maybe) { return RxJavaObservablePlugins.onAssembly((Maybe<T>)source); } ObjectHelper.requireNonNull(source, "onSubscribe is null"); return RxJavaObs... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> wrap(MaybeSource<T> source) { if (source instanceof Maybe) { return RxJavaObservablePlugins.onAssembly((Maybe<T>)source); } ObjectHelper.requireNonNull(source, "onSubscribe is null"); return RxJavaObs... |
@Test public void emptySingleton() { assertSame(Maybe.empty(), Maybe.empty()); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(fin... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> empty() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeEmpty.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(fin... |
@Test public void neverSingleton() { assertSame(Maybe.never(), Maybe.never()); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(fin... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Maybe<T> never() { return RxJavaObservablePlugins.onAssembly((Maybe<T>)MaybeNever.INSTANCE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(fin... |
@Test public void equalsWith() { Timed<Integer> t1 = new Timed<Integer>(1, 5, TimeUnit.SECONDS); Timed<Integer> t2 = new Timed<Integer>(1, 5, TimeUnit.SECONDS); Timed<Integer> t3 = new Timed<Integer>(2, 5, TimeUnit.SECONDS); Timed<Integer> t4 = new Timed<Integer>(1, 4, TimeUnit.SECONDS); Timed<Integer> t5 = new Timed<I... | @Override public boolean equals(Object other) { if (other instanceof Timed) { Timed<?> o = (Timed<?>) other; return ObjectHelper.equals(value, o.value) && time == o.time && ObjectHelper.equals(unit, o.unit); } return false; } | Timed { @Override public boolean equals(Object other) { if (other instanceof Timed) { Timed<?> o = (Timed<?>) other; return ObjectHelper.equals(value, o.value) && time == o.time && ObjectHelper.equals(unit, o.unit); } return false; } } | Timed { @Override public boolean equals(Object other) { if (other instanceof Timed) { Timed<?> o = (Timed<?>) other; return ObjectHelper.equals(value, o.value) && time == o.time && ObjectHelper.equals(unit, o.unit); } return false; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); } | Timed { @Override public boolean equals(Object other) { if (other instanceof Timed) { Timed<?> o = (Timed<?>) other; return ObjectHelper.equals(value, o.value) && time == o.time && ObjectHelper.equals(unit, o.unit); } return false; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNu... | Timed { @Override public boolean equals(Object other) { if (other instanceof Timed) { Timed<?> o = (Timed<?>) other; return ObjectHelper.equals(value, o.value) && time == o.time && ObjectHelper.equals(unit, o.unit); } return false; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNu... |
@Test(expected = NullPointerException.class) public void deferNull() { Maybe.defer(null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<T>(maybeSupplier)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<... |
@Test public void defer() { Maybe<Integer> source = Maybe.defer(new Callable<Maybe<Integer>>() { int count; @Override public Maybe<Integer> call() throws Exception { return Maybe.just(count++); } }); for (int i = 0; i < 128; i++) { source.test().assertResult(i); } } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<T>(maybeSupplier)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> defer(final Callable<? extends MaybeSource<? extends T>> maybeSupplier) { ObjectHelper.requireNonNull(maybeSupplier, "maybeSupplier is null"); return RxJavaObservablePlugins.onAssembly(new MaybeDefer<... |
@Test public void unsafeCreate() { Maybe.unsafeCreate(new MaybeSource<Integer>() { @Override public void subscribe(MaybeObserver<? super Integer> observer) { observer.onSubscribe(Disposables.empty()); observer.onSuccess(1); } }) .test() .assertResult(1); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); return RxJ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, ... |
@Test(expected = NullPointerException.class) public void unsafeCreateNull() { Maybe.unsafeCreate(null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); return RxJ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe) { if (onSubscribe instanceof Maybe) { throw new IllegalArgumentException("unsafeCreate(Maybe) should be upgraded"); } ObjectHelper.requireNonNull(onSubscribe, ... |
@Test public void to() { Maybe.just(1).to(new Function<Maybe<Integer>, Observable<Integer>>() { @Override public Observable<Integer> apply(Maybe<Integer> v) throws Exception { return v.toObservable(); } }) .test() .assertResult(1); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Maybe<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOrThrow(ex); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Maybe<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOr... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Maybe<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOr... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Maybe<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOr... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> R to(Function<? super Maybe<T>, R> convert) { try { return ObjectHelper.requireNonNull(convert, "convert is null").apply(this); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); throw ExceptionHelper.wrapOr... |
@Test public void compose() { Maybe.just(1).compose(new MaybeTransformer<Integer, Integer>() { @Override public MaybeSource<Integer> apply(Maybe<Integer> m) { return m.map(new Function<Integer, Integer>() { @Override public Integer apply(Integer w) throws Exception { return w + 1; } }); } }) .test() .assertResult(2); } | @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> compose(MaybeTransformer<? super T, ? extends R> transformer) { return wrap(((MaybeTransformer<T, R>) ObjectHelper.requireNonNull(transformer, "transformer is null")).apply(this)); } | Maybe implements MaybeSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> compose(MaybeTransformer<? super T, ? extends R> transformer) { return wrap(((MaybeTransformer<T, R>) ObjectHelper.requireNonNull(transformer, "transformer is null")).app... | Maybe implements MaybeSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> compose(MaybeTransformer<? super T, ? extends R> transformer) { return wrap(((MaybeTransformer<T, R>) ObjectHelper.requireNonNull(transformer, "transformer is null")).app... | Maybe implements MaybeSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> compose(MaybeTransformer<? super T, ? extends R> transformer) { return wrap(((MaybeTransformer<T, R>) ObjectHelper.requireNonNull(transformer, "transformer is null")).app... | Maybe implements MaybeSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> compose(MaybeTransformer<? super T, ? extends R> transformer) { return wrap(((MaybeTransformer<T, R>) ObjectHelper.requireNonNull(transformer, "transformer is null")).app... |
@Test public void map() { Maybe.just(1).map(new Function<Integer, String>() { @Override public String apply(Integer v) throws Exception { return v.toString(); } }).test().assertResult("1"); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeMap<T, R>(this, mapper)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeMap<T, R>(this, mapper)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeMap<T, R>(this, mapper)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeMap<T, R>(this, mapper)); } @CheckReturnValue @... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeMap<T, R>(this, mapper)); } @CheckReturnValue @... |
@Test public void cast() { TestObserver<Number> ts = Maybe.just(1).cast(Number.class).test(); ts.assertResult((Number)1); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Maybe<U> cast(final Class<? extends U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return map(Functions.castFunction(clazz)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Maybe<U> cast(final Class<? extends U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return map(Functions.castFunction(clazz)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Maybe<U> cast(final Class<? extends U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return map(Functions.castFunction(clazz)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Maybe<U> cast(final Class<? extends U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return map(Functions.castFunction(clazz)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) stat... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U> Maybe<U> cast(final Class<? extends U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return map(Functions.castFunction(clazz)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) stat... |
@Test public void observeOnDoubleSubscribe() { TestHelper.checkDoubleOnSubscribeMaybe(new Function<Maybe<Object>, MaybeSource<Object>>() { @Override public MaybeSource<Object> apply(Maybe<Object> m) throws Exception { return m.observeOn(Schedulers.single()); } }); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe<T> observeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); return RxJavaObservablePlugins.onAssembly(new MaybeObserveOn<T>(this, scheduler)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe<T> observeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); return RxJavaObservablePlugins.onAssembly(new MaybeObserveOn<T>(this, scheduler)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe<T> observeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); return RxJavaObservablePlugins.onAssembly(new MaybeObserveOn<T>(this, scheduler)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe<T> observeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); return RxJavaObservablePlugins.onAssembly(new MaybeObserveOn<T>(this, scheduler)); } @CheckReturnValue... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) public final Maybe<T> observeOn(final Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is null"); return RxJavaObservablePlugins.onAssembly(new MaybeObserveOn<T>(this, scheduler)); } @CheckReturnValue... |
@Test public void fromAction() { final int[] call = { 0 }; Maybe.fromAction(new Action() { @Override public void run() throws Exception { call[0]++; } }) .test() .assertResult(); assertEquals(1, call[0]); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromAction(final Action run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromAction<T>(run)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromAction(final Action run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromAction<T>(run)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromAction(final Action run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromAction<T>(run)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromAction(final Action run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromAction<T>(run)); } @CheckReturnValue @SchedulerSupport(Scheduler... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromAction(final Action run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromAction<T>(run)); } @CheckReturnValue @SchedulerSupport(Scheduler... |
@Test public void toStringOf() { Timed<Integer> t1 = new Timed<Integer>(1, 5, TimeUnit.SECONDS); assertEquals("Timed[time=5, unit=SECONDS, value=1]", t1.toString()); } | @Override public String toString() { return "Timed[time=" + time + ", unit=" + unit + ", value=" + value + "]"; } | Timed { @Override public String toString() { return "Timed[time=" + time + ", unit=" + unit + ", value=" + value + "]"; } } | Timed { @Override public String toString() { return "Timed[time=" + time + ", unit=" + unit + ", value=" + value + "]"; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); } | Timed { @Override public String toString() { return "Timed[time=" + time + ", unit=" + unit + ", value=" + value + "]"; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNull TimeUnit unit(); long time(); long time(@NonNull TimeUnit unit); @Override boolean equals(Object other); @Ove... | Timed { @Override public String toString() { return "Timed[time=" + time + ", unit=" + unit + ", value=" + value + "]"; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNull TimeUnit unit(); long time(); long time(@NonNull TimeUnit unit); @Override boolean equals(Object other); @Ove... |
@Test public void fromRunnable() { final int[] call = { 0 }; Maybe.fromRunnable(new Runnable() { @Override public void run() { call[0]++; } }) .test() .assertResult(); assertEquals(1, call[0]); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromRunnable(final Runnable run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromRunnable<T>(run)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromRunnable(final Runnable run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromRunnable<T>(run)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromRunnable(final Runnable run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromRunnable<T>(run)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromRunnable(final Runnable run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromRunnable<T>(run)); } @CheckReturnValue @SchedulerSupport(Sch... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromRunnable(final Runnable run) { ObjectHelper.requireNonNull(run, "run is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromRunnable<T>(run)); } @CheckReturnValue @SchedulerSupport(Sch... |
@Test public void doOnSuccess() { final Integer[] value = { null }; Maybe.just(1).doOnSuccess(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { value[0] = v; } }) .test() .assertResult(1); assertEquals(1, value[0].intValue()); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSuccess(Consumer<? super T> onSuccess) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), ObjectHelper.requireNonNull(onSuccess, "onSubscribe is null"), Functions.emptyConsumer(), Functions.EM... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSuccess(Consumer<? super T> onSuccess) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), ObjectHelper.requireNonNull(onSuccess, "onSubscribe is null"), Funct... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSuccess(Consumer<? super T> onSuccess) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), ObjectHelper.requireNonNull(onSuccess, "onSubscribe is null"), Funct... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSuccess(Consumer<? super T> onSuccess) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), ObjectHelper.requireNonNull(onSuccess, "onSubscribe is null"), Funct... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSuccess(Consumer<? super T> onSuccess) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), ObjectHelper.requireNonNull(onSuccess, "onSubscribe is null"), Funct... |
@Test public void doOnSubscribe() { final Disposable[] value = { null }; Maybe.just(1).doOnSubscribe(new Consumer<Disposable>() { @Override public void accept(Disposable v) throws Exception { value[0] = v; } }) .test() .assertResult(1); assertNotNull(value[0]); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSubscribe(Consumer<? super Disposable> onSubscribe) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"), Functions.emptyConsumer(), Functions.emptyConsumer(... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSubscribe(Consumer<? super Disposable> onSubscribe) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"), Functions.emptyCo... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSubscribe(Consumer<? super Disposable> onSubscribe) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"), Functions.emptyCo... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSubscribe(Consumer<? super Disposable> onSubscribe) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"), Functions.emptyCo... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnSubscribe(Consumer<? super Disposable> onSubscribe) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"), Functions.emptyCo... |
@Test public void doOnDispose() { final int[] call = { 0 }; Maybe.just(1).doOnDispose(new Action() { @Override public void run() throws Exception { call[0]++; } }) .test(true) .assertSubscribed() .assertNoValues() .assertNoErrors() .assertNotComplete(); assertEquals(1, call[0]); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnDispose(Action onDispose) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, Functions.EMPTY_ACTION, ObjectHelper.... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnDispose(Action onDispose) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, Fun... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnDispose(Action onDispose) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, Fun... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnDispose(Action onDispose) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, Fun... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> doOnDispose(Action onDispose) { return RxJavaObservablePlugins.onAssembly(new MaybePeek<T>(this, Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, Fun... |
@Test public void flatMap() { Maybe.just(1).flatMap(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { return Maybe.just(v * 10); } }) .test() .assertResult(10); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> flatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this, mapper)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> flatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this, m... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> flatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this, m... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> flatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this, m... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> flatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this, m... |
@Test public void concatMap() { Maybe.just(1).concatMap(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { return Maybe.just(v * 10); } }) .test() .assertResult(10); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> concatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this, mapper)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> concatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this,... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> concatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this,... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> concatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this,... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <R> Maybe<R> concatMap(Function<? super T, ? extends MaybeSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFlatten<T, R>(this,... |
@Test public void completableToMaybe() { Completable.complete() .toMaybe() .test() .assertResult(); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSource<... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final TestObserver<T> test() { TestObserver<T> ts = new TestObserver<T>(); subscribe(ts); return ts; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSource<... |
@Test(expected = NullPointerException.class) public void nullArgument() { Maybe.create(null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe) { ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); return RxJavaObservablePlugins.onAssembly(new MaybeCreate<T>(onSubscribe)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe) { ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); return RxJavaObservablePlugins.onAssembly(new MaybeCreate<T>(onSubscribe)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe) { ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); return RxJavaObservablePlugins.onAssembly(new MaybeCreate<T>(onSubscribe)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe) { ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); return RxJavaObservablePlugins.onAssembly(new MaybeCreate<T>(onSubscribe)); } @CheckReturnVa... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe) { ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); return RxJavaObservablePlugins.onAssembly(new MaybeCreate<T>(onSubscribe)); } @CheckReturnVa... |
@Test(expected = NullPointerException.class) public void ambIterableNull() { Maybe.amb((Iterable<Maybe<Integer>>)null); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); return RxJavaObservablePlugins.onAssembly(new MaybeAmb<T>(null, sources)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); return RxJavaObservablePlugins.onAssembly(new MaybeAmb<T>(null, sources)); } ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); return RxJavaObservablePlugins.onAssembly(new MaybeAmb<T>(null, sources)); } ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); return RxJavaObservablePlugins.onAssembly(new MaybeAmb<T>(null, sources)); } ... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources) { ObjectHelper.requireNonNull(sources, "sources is null"); return RxJavaObservablePlugins.onAssembly(new MaybeAmb<T>(null, sources)); } ... |
@SuppressWarnings("unchecked") @Test public void mergeArray() { Maybe.mergeArray(Maybe.just(1), Maybe.just(2), Maybe.just(3)) .test() .assertResult(1, 2, 3); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> mergeArray(MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return Observable.empty(); } if (sources.length == 1) { return R... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> mergeArray(MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return Observable.empty(); } i... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> mergeArray(MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return Observable.empty(); } i... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> mergeArray(MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return Observable.empty(); } i... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @SuppressWarnings("unchecked") public static <T> Observable<T> mergeArray(MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return Observable.empty(); } i... |
@Test public void testClear() { Disposable s1 = Disposables.empty(); Disposable s2 = Disposables.empty(); CompositeDisposable s = new CompositeDisposable(); s.add(s1); s.add(s2); assertFalse(s1.isDisposed()); assertFalse(s2.isDisposed()); s.clear(); assertTrue(s1.isDisposed()); assertTrue(s2.isDisposed()); assertFalse(... | public void clear() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } set = resources; resources = null; } dispose(set); } | CompositeDisposable implements Disposable, DisposableContainer { public void clear() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } set = resources; resources = null; } dispose(set); } } | CompositeDisposable implements Disposable, DisposableContainer { public void clear() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } set = resources; resources = null; } dispose(set); } CompositeDisposable(); CompositeDisposable(@NonNull Disposable... resources)... | CompositeDisposable implements Disposable, DisposableContainer { public void clear() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } set = resources; resources = null; } dispose(set); } CompositeDisposable(); CompositeDisposable(@NonNull Disposable... resources)... | CompositeDisposable implements Disposable, DisposableContainer { public void clear() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } set = resources; resources = null; } dispose(set); } CompositeDisposable(); CompositeDisposable(@NonNull Disposable... resources)... |
@Test public void disposePeriodicDirect() { final int[] count = { 0 }; TestScheduler scheduler = new TestScheduler(); Disposable d = scheduler.schedulePeriodicallyDirect(new Runnable() { @Override public void run() { count[0]++; } }, 100, 100, TimeUnit.MILLISECONDS); d.dispose(); assertEquals(0, count[0]); assertTrue(d... | @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w); Disposable... | Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w)... | Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w)... | Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w)... | Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w)... |
@Test public void subscribeWith() { MaybeObserver<Integer> mo = new MaybeObserver<Integer>() { @Override public void onSubscribe(Disposable d) { } @Override public void onSuccess(Integer value) { } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }; assertSame(mo, Maybe.just(1).subs... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <E extends MaybeObserver<? super T>> E subscribeWith(E observer) { subscribe(observer); return observer; } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <E extends MaybeObserver<? super T>> E subscribeWith(E observer) { subscribe(observer); return observer; } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <E extends MaybeObserver<? super T>> E subscribeWith(E observer) { subscribe(observer); return observer; } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <E extends MaybeObserver<? super T>> E subscribeWith(E observer) { subscribe(observer); return observer; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends Ma... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <E extends MaybeObserver<? super T>> E subscribeWith(E observer) { subscribe(observer); return observer; } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends Ma... |
@SuppressWarnings("unchecked") @Test public void concatArrayDelayError() { Maybe.concatArrayDelayError(Maybe.empty(), Maybe.just(1), Maybe.error(new TestException())) .test() .assertFailure(TestException.class, 1); Maybe.concatArrayDelayError(Maybe.error(new TestException()), Maybe.empty(), Maybe.just(1)) .test() .asse... | @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> concatArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } else if (sources.length == 1) { return RxJavaObservablePlugins.onAssembly(new May... | Maybe implements MaybeSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> concatArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } else if (sources.length == 1) { return RxJavaOb... | Maybe implements MaybeSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> concatArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } else if (sources.length == 1) { return RxJavaOb... | Maybe implements MaybeSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> concatArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } else if (sources.length == 1) { return RxJavaOb... | Maybe implements MaybeSource<T> { @SuppressWarnings("unchecked") @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> concatArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } else if (sources.length == 1) { return RxJavaOb... |
@Test public void fromFuture() { Maybe.fromFuture(Observable.just(1).delay(200, TimeUnit.MILLISECONDS).toFuture()) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1) ; Maybe.fromFuture(emptyFuture()) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult() ; Maybe.fromFuture(Observable.error(new TestException()).d... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromFuture(Future<? extends T> future) { ObjectHelper.requireNonNull(future, "future is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromFuture<T>(future, 0L, null)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromFuture(Future<? extends T> future) { ObjectHelper.requireNonNull(future, "future is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromFuture<T>(future, 0L, null)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromFuture(Future<? extends T> future) { ObjectHelper.requireNonNull(future, "future is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromFuture<T>(future, 0L, null)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromFuture(Future<? extends T> future) { ObjectHelper.requireNonNull(future, "future is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromFuture<T>(future, 0L, null)); } @CheckReturnValu... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Maybe<T> fromFuture(Future<? extends T> future) { ObjectHelper.requireNonNull(future, "future is null"); return RxJavaObservablePlugins.onAssembly(new MaybeFromFuture<T>(future, 0L, null)); } @CheckReturnValu... |
@SuppressWarnings("unchecked") @Test public void mergeArrayDelayError() { Maybe.mergeArrayDelayError(Maybe.empty(), Maybe.just(1), Maybe.error(new TestException())) .test() .assertFailure(TestException.class, 1); Maybe.mergeArrayDelayError(Maybe.error(new TestException()), Maybe.empty(), Maybe.just(1)) .test() .assertF... | @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> mergeArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } return Observable.fromArray(sources).flatMap((Function)MaybeToObse... | Maybe implements MaybeSource<T> { @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> mergeArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } return Observable.fromArray(sour... | Maybe implements MaybeSource<T> { @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> mergeArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } return Observable.fromArray(sour... | Maybe implements MaybeSource<T> { @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> mergeArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } return Observable.fromArray(sour... | Maybe implements MaybeSource<T> { @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> mergeArrayDelayError(MaybeSource<? extends T>... sources) { if (sources.length == 0) { return Observable.empty(); } return Observable.fromArray(sour... |
@Test public void sequenceEqual() { Maybe.sequenceEqual(Maybe.just(1), Maybe.just(new Integer(1))).test().assertResult(true); Maybe.sequenceEqual(Maybe.just(1), Maybe.just(2)).test().assertResult(false); Maybe.sequenceEqual(Maybe.just(1), Maybe.empty()).test().assertResult(false); Maybe.sequenceEqual(Maybe.empty(), May... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<Boolean> sequenceEqual(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2) { return sequenceEqual(source1, source2, ObjectHelper.equalsPredicate()); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<Boolean> sequenceEqual(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2) { return sequenceEqual(source1, source2, ObjectHelper.equalsPredicate()); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<Boolean> sequenceEqual(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2) { return sequenceEqual(source1, source2, ObjectHelper.equalsPredicate()); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<Boolean> sequenceEqual(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2) { return sequenceEqual(source1, source2, ObjectHelper.equalsPredicate()); } @CheckReturnValue @SchedulerSuppor... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T> Single<Boolean> sequenceEqual(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2) { return sequenceEqual(source1, source2, ObjectHelper.equalsPredicate()); } @CheckReturnValue @SchedulerSuppor... |
@Test public void timer() { Maybe.timer(100, TimeUnit.MILLISECONDS) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(0L); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public static Maybe<Long> timer(long delay, TimeUnit unit) { return timer(delay, unit, Schedulers.computation()); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public static Maybe<Long> timer(long delay, TimeUnit unit) { return timer(delay, unit, Schedulers.computation()); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public static Maybe<Long> timer(long delay, TimeUnit unit) { return timer(delay, unit, Schedulers.computation()); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public static Maybe<Long> timer(long delay, TimeUnit unit) { return timer(delay, unit, Schedulers.computation()); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public static Maybe<Long> timer(long delay, TimeUnit unit) { return timer(delay, unit, Schedulers.computation()); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends... |
@Test public void blockingGet() { assertEquals(1, Maybe.just(1).blockingGet().intValue()); assertEquals(100, Maybe.empty().blockingGet(100)); try { Maybe.error(new TestException()).blockingGet(); fail("Should have thrown!"); } catch (TestException ex) { } try { Maybe.error(new TestException()).blockingGet(100); fail("S... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final T blockingGet() { BlockingMultiObserver<T> observer = new BlockingMultiObserver<T>(); subscribe(observer); return observer.blockingGet(); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final T blockingGet() { BlockingMultiObserver<T> observer = new BlockingMultiObserver<T>(); subscribe(observer); return observer.blockingGet(); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final T blockingGet() { BlockingMultiObserver<T> observer = new BlockingMultiObserver<T>(); subscribe(observer); return observer.blockingGet(); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final T blockingGet() { BlockingMultiObserver<T> observer = new BlockingMultiObserver<T>(); subscribe(observer); return observer.blockingGet(); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final T blockingGet() { BlockingMultiObserver<T> observer = new BlockingMultiObserver<T>(); subscribe(observer); return observer.blockingGet(); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T... |
@Test public void using() { final AtomicInteger disposeCount = new AtomicInteger(); Maybe.using(Functions.justCallable(1), new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { return Maybe.just(v); } }, new Consumer<Integer>() { @Override public void ... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, D> Maybe<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends MaybeSource<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer) { return using(resourceSupplier, sourceSupplier, resourceDisposer, true); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, D> Maybe<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends MaybeSource<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer) { return using(resourceSupplier, sourceSu... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, D> Maybe<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends MaybeSource<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer) { return using(resourceSupplier, sourceSu... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, D> Maybe<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends MaybeSource<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer) { return using(resourceSupplier, sourceSu... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, D> Maybe<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends MaybeSource<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer) { return using(resourceSupplier, sourceSu... |
@SuppressWarnings("unchecked") @Test public void zipArray() { Maybe.zipArray(arrayToString, Maybe.just(1), Maybe.just(2)) .test() .assertResult("[1, 2]"); Maybe.zipArray(arrayToString, Maybe.just(1), Maybe.empty()) .test() .assertResult(); Maybe.zipArray(arrayToString, Maybe.just(1), Maybe.error(new TestException())) .... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Maybe<R> zipArray(Function<? super Object[], ? extends R> zipper, MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return empty(); } ObjectHelper.requireNonNull(zippe... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Maybe<R> zipArray(Function<? super Object[], ? extends R> zipper, MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return empty(); }... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Maybe<R> zipArray(Function<? super Object[], ? extends R> zipper, MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return empty(); }... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Maybe<R> zipArray(Function<? super Object[], ? extends R> zipper, MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return empty(); }... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static <T, R> Maybe<R> zipArray(Function<? super Object[], ? extends R> zipper, MaybeSource<? extends T>... sources) { ObjectHelper.requireNonNull(sources, "sources is null"); if (sources.length == 0) { return empty(); }... |
@SuppressWarnings("unchecked") @Test public void zipWith() { Maybe.just(1).zipWith(Maybe.just(2), ArgsToString.INSTANCE) .test() .assertResult("12"); } | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Maybe<R> zipWith(MaybeSource<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { ObjectHelper.requireNonNull(other, "other is null"); return zip(this, other, zipper); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Maybe<R> zipWith(MaybeSource<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { ObjectHelper.requireNonNull(other, "other is null"); return zip(this, other, zipper); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Maybe<R> zipWith(MaybeSource<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { ObjectHelper.requireNonNull(other, "other is null"); return zip(this, other, zipper); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Maybe<R> zipWith(MaybeSource<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { ObjectHelper.requireNonNull(other, "other is null"); return zip(this, other, zipper); } @CheckReturnV... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final <U, R> Maybe<R> zipWith(MaybeSource<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) { ObjectHelper.requireNonNull(other, "other is null"); return zip(this, other, zipper); } @CheckReturnV... |
@Test(expected = NullPointerException.class) public void testAddingNullDisposableIllegal() { CompositeDisposable csub = new CompositeDisposable(); csub.add(null); } | @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 onTerminateDetach() throws Exception { System.gc(); Thread.sleep(150); long before = usedMemoryNow(); Maybe<Object> source = Observable.just((Object)new Object[10000000]).singleElement(); long middle = usedMemoryNow(); MaybeObserver<Object> observer = new MaybeObserver<Object>() { @SuppressWarnings("u... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> onTerminateDetach() { return RxJavaObservablePlugins.onAssembly(new MaybeDetach<T>(this)); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> onTerminateDetach() { return RxJavaObservablePlugins.onAssembly(new MaybeDetach<T>(this)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> onTerminateDetach() { return RxJavaObservablePlugins.onAssembly(new MaybeDetach<T>(this)); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> onTerminateDetach() { return RxJavaObservablePlugins.onAssembly(new MaybeDetach<T>(this)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSo... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> onTerminateDetach() { return RxJavaObservablePlugins.onAssembly(new MaybeDetach<T>(this)); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSo... |
@Test public void repeat() { Maybe.just(1).repeat().take(5).test().assertResult(1, 1, 1, 1, 1); Maybe.just(1).repeat(5).test().assertResult(1, 1, 1, 1, 1); Maybe.just(1).repeatUntil(new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return false; } }).take(5).test().assertResult(1, 1, 1,... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> repeat() { return repeat(Long.MAX_VALUE); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> repeat() { return repeat(Long.MAX_VALUE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> repeat() { return repeat(Long.MAX_VALUE); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> repeat() { return repeat(Long.MAX_VALUE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources); @CheckReturnVal... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Observable<T> repeat() { return repeat(Long.MAX_VALUE); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources); @CheckReturnVal... |
@Test public void retry() { Maybe.just(1).retry().test().assertResult(1); Maybe.just(1).retry(5).test().assertResult(1); Maybe.just(1).retry(Functions.alwaysTrue()).test().assertResult(1); Maybe.just(1).retry(5, Functions.alwaysTrue()).test().assertResult(1); Maybe.just(1).retry(new BiPredicate<Integer, Throwable>() { ... | @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> retry() { return retry(Long.MAX_VALUE, Functions.alwaysTrue()); } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> retry() { return retry(Long.MAX_VALUE, Functions.alwaysTrue()); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> retry() { return retry(Long.MAX_VALUE, Functions.alwaysTrue()); } } | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> retry() { return retry(Long.MAX_VALUE, Functions.alwaysTrue()); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources)... | Maybe implements MaybeSource<T> { @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> retry() { return retry(Long.MAX_VALUE, Functions.alwaysTrue()); } @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) static Maybe<T> amb(final Iterable<? extends MaybeSource<? extends T>> sources)... |
@Test public void cancel() throws Exception { assertFalse(fo.isDone()); assertFalse(fo.isCancelled()); fo.cancel(false); assertTrue(fo.isDone()); assertTrue(fo.isCancelled()); try { fo.get(); fail("Should have thrown"); } catch (CancellationException ex) { } try { fo.get(1, TimeUnit.MILLISECONDS); fail("Should have thr... | @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null) { a.dispose(); } countDown(); return true; } } } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null)... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null)... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null)... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null)... |
@Test public void onError() throws Exception { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { fo.onError(new TestException("One")); fo.onError(new TestException("Two")); try { fo.get(5, TimeUnit.MILLISECONDS); } catch (ExecutionException ex) { assertTrue(ex.toString(), ex.getCause() instanceof Tes... | @Override public void onError(Throwable t) { if (error == null) { error = t; for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { RxJavaCommonPlugins.onError(t); return; } if (s.compareAndSet(a, this)) { countDown(); return; } } } else { RxJavaCommonPlugins.onError(t); } } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onError(Throwable t) { if (error == null) { error = t; for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { RxJavaCommonPlugins.onError(t); return; } if (s.compareAndSet(a, this))... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onError(Throwable t) { if (error == null) { error = t; for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { RxJavaCommonPlugins.onError(t); return; } if (s.compareAndSet(a, this))... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onError(Throwable t) { if (error == null) { error = t; for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { RxJavaCommonPlugins.onError(t); return; } if (s.compareAndSet(a, this))... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onError(Throwable t) { if (error == null) { error = t; for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { RxJavaCommonPlugins.onError(t); return; } if (s.compareAndSet(a, this))... |
@Test public void onNext() throws Exception { fo.onNext(1); fo.onComplete(); assertEquals(1, fo.get(5, TimeUnit.MILLISECONDS).intValue()); } | @Override public void onNext(T t) { if (value != null) { s.get().dispose(); onError(new IndexOutOfBoundsException("More than one element received")); return; } value = t; } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onNext(T t) { if (value != null) { s.get().dispose(); onError(new IndexOutOfBoundsException("More than one element received")); return; } value = t; } } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onNext(T t) { if (value != null) { s.get().dispose(); onError(new IndexOutOfBoundsException("More than one element received")); return; } value = t; } FutureObserver(); } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onNext(T t) { if (value != null) { s.get().dispose(); onError(new IndexOutOfBoundsException("More than one element received")); return; } value = t; } FutureObserver(); @Override boolean cancel(boolean mayInterru... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onNext(T t) { if (value != null) { s.get().dispose(); onError(new IndexOutOfBoundsException("More than one element received")); return; } value = t; } FutureObserver(); @Override boolean cancel(boolean mayInterru... |
@Test public void onSubscribe() throws Exception { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { Disposable s = Disposables.empty(); fo.onSubscribe(s); Disposable s2 = Disposables.empty(); fo.onSubscribe(s2); assertFalse(s.isDisposed()); assertTrue(s2.isDisposed()); TestCommonHelper.assertError(e... | @Override public void onSubscribe(Disposable s) { DisposableHelper.setOnce(this.s, s); } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onSubscribe(Disposable s) { DisposableHelper.setOnce(this.s, s); } } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onSubscribe(Disposable s) { DisposableHelper.setOnce(this.s, s); } FutureObserver(); } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onSubscribe(Disposable s) { DisposableHelper.setOnce(this.s, s); } FutureObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onSubscribe(Disposable s) { DisposableHelper.setOnce(this.s, s); } FutureObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override... |
@Test public void cancelRace() { for (int i = 0; i < 500; i++) { final FutureObserver<Integer> fo = new FutureObserver<Integer>(); Runnable r = new Runnable() { @Override public void run() { fo.cancel(false); } }; TestCommonHelper.race(r, r, Schedulers.single()); } } | @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null) { a.dispose(); } countDown(); return true; } } } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null)... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null)... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null)... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null)... |
@Test(expected = InterruptedException.class) public void getInterrupted() throws Exception { Thread.currentThread().interrupt(); fo.get(); } | @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex != null) { throw new ExecutionException(ex); } return value; } | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex !=... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex !=... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex !=... | FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex !=... |
@Test public void cancel() { final Future<?> f = Single.never().toFuture(); assertFalse(f.isCancelled()); assertFalse(f.isDone()); f.cancel(true); assertTrue(f.isCancelled()); assertTrue(f.isDone()); try { f.get(); fail("Should have thrown!"); } catch (CancellationException ex) { } catch (InterruptedException ex) { thr... | @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null) { a.dispose(); } countDown(); return true; } } } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... |
@Test public void addAll() { CompositeDisposable cd = new CompositeDisposable(); Disposable d1 = Disposables.empty(); Disposable d2 = Disposables.empty(); Disposable d3 = Disposables.empty(); cd.addAll(d1, d2); cd.addAll(d3); assertFalse(d1.isDisposed()); assertFalse(d2.isDisposed()); assertFalse(d3.isDisposed()); cd.c... | 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 cancelRace() { for (int i = 0; i < 500; i++) { final Future<?> f = Single.never().toFuture(); Runnable r = new Runnable() { @Override public void run() { f.cancel(true); } }; TestCommonHelper.race(r, r, Schedulers.single()); } } | @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null) { a.dispose(); } countDown(); return true; } } } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... |
@Test public void timeout() throws Exception { Future<?> f = Single.never().toFuture(); try { f.get(100, TimeUnit.MILLISECONDS); fail("Should have thrown"); } catch (TimeoutException ex) { } } | @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex != null) { throw new ExecutionException(ex); } return value; } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... |
@Test public void dispose() { Future<Integer> f = Single.just(1).toFuture(); ((Disposable)f).dispose(); assertTrue(((Disposable)f).isDisposed()); } | @Override public void dispose() { } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public void dispose() { } } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public void dispose() { } FutureSingleObserver(); } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public void dispose() { } FutureSingleObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long time... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public void dispose() { } FutureSingleObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long time... |
@Test public void errorGetWithTimeout() throws Exception { Future<?> f = Single.error(new TestException()).toFuture(); try { f.get(5, TimeUnit.SECONDS); fail("Should have thrown"); } catch (ExecutionException ex) { assertTrue(ex.toString(), ex.getCause() instanceof TestException); } } | @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex != null) { throw new ExecutionException(ex); } return value; } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... |
@Test public void normalGetWitHTimeout() throws Exception { Future<Integer> f = Single.just(1).toFuture(); assertEquals(1, f.get(5, TimeUnit.SECONDS).intValue()); } | @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex != null) { throw new ExecutionException(ex); } return value; } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... |
@Test public void getAwait() throws Exception { Future<Integer> f = Single.just(1).delay(100, TimeUnit.MILLISECONDS).toFuture(); assertEquals(1, f.get(5, TimeUnit.SECONDS).intValue()); } | @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex != null) { throw new ExecutionException(ex); } return value; } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = erro... |
@Test public void onSuccessCancelRace() { for (int i = 0; i < 500; i++) { final PublishSubject<Integer> ps = PublishSubject.create(); final Future<?> f = ps.single(-99).toFuture(); ps.onNext(1); Runnable r1 = new Runnable() { @Override public void run() { f.cancel(true); } }; Runnable r2 = new Runnable() { @Override pu... | @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null) { a.dispose(); } countDown(); return true; } } } | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... | FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this || a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if... |
@Test(expected = UnsupportedOperationException.class) public void offer() { TestObserver<Integer> to = new TestObserver<Integer>(); BasicFuseableObserver<Integer, Integer> o = new BasicFuseableObserver<Integer, Integer>(to) { @Nullable @Override public Integer poll() throws Exception { return null; } @Override public i... | @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } | BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } } | BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } BasicFuseableObserver(Observer<? super R> actual); } | BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } BasicFuseableObserver(Observer<? super R> actual); @SuppressWarnings("unchecked") @Override final void onSubscribe(Disposable s); @Override v... | BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } BasicFuseableObserver(Observer<? super R> actual); @SuppressWarnings("unchecked") @Override final void onSubscribe(Disposable s); @Override v... |
@Test(expected = UnsupportedOperationException.class) public void offer2() { BasicFuseableObserver<Integer, Integer> o = new BasicFuseableObserver<Integer, Integer>(new TestObserver<Integer>()) { @Nullable @Override public Integer poll() throws Exception { return null; } @Override public int requestFusion(int mode) { r... | @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } | BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } } | BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } BasicFuseableObserver(Observer<? super R> actual); } | BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } BasicFuseableObserver(Observer<? super R> actual); @SuppressWarnings("unchecked") @Override final void onSubscribe(Disposable s); @Override v... | BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } BasicFuseableObserver(Observer<? super R> actual); @SuppressWarnings("unchecked") @Override final void onSubscribe(Disposable s); @Override v... |
@Test public void normal() { TestObserver<Integer> to = new TestObserver<Integer>(); TakeFirst source = new TakeFirst(to); source.onSubscribe(Disposables.empty()); Disposable d = Disposables.empty(); source.onSubscribe(d); assertTrue(d.isDisposed()); source.onNext(1); to.assertResult(1); } | @Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); } } | DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); } } } | DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); } } DeferredScalarObserver(Observer<? super R> actual); } | DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); } } DeferredScalarObserver(Observer<? super R> actual); @Override void onSubscribe(Disposable s); @Overr... | DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); } } DeferredScalarObserver(Observer<? super R> actual); @Override void onSubscribe(Disposable s); @Overr... |
@Test public void delete() { CompositeDisposable cd = new CompositeDisposable(); Disposable d1 = Disposables.empty(); assertFalse(cd.delete(d1)); Disposable d2 = Disposables.empty(); cd.add(d2); assertFalse(cd.delete(d1)); cd.dispose(); assertFalse(cd.delete(d1)); } | @Override public boolean delete(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "Disposable item is null"); if (disposed) { return false; } synchronized (this) { if (disposed) { return false; } OpenHashSet<Disposable> set = resources; if (set == null || !set.remove(d)) { return false; } } return true; } | CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean delete(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "Disposable item is null"); if (disposed) { return false; } synchronized (this) { if (disposed) { return false; } OpenHashSet<Disposable> set = resources; if (set == n... | CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean delete(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "Disposable item is null"); if (disposed) { return false; } synchronized (this) { if (disposed) { return false; } OpenHashSet<Disposable> set = resources; if (set == n... | CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean delete(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "Disposable item is null"); if (disposed) { return false; } synchronized (this) { if (disposed) { return false; } OpenHashSet<Disposable> set = resources; if (set == n... | CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean delete(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "Disposable item is null"); if (disposed) { return false; } synchronized (this) { if (disposed) { return false; } OpenHashSet<Disposable> set = resources; if (set == n... |
@Test public void dispose() { TestObserver<Integer> to = new TestObserver<Integer>(); TakeFirst source = new TakeFirst(to); Disposable d = Disposables.empty(); source.onSubscribe(d); assertFalse(d.isDisposed()); to.cancel(); assertTrue(d.isDisposed()); assertTrue(source.isDisposed()); } | @Override public void dispose() { super.dispose(); s.dispose(); } | DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void dispose() { super.dispose(); s.dispose(); } } | DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void dispose() { super.dispose(); s.dispose(); } DeferredScalarObserver(Observer<? super R> actual); } | DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void dispose() { super.dispose(); s.dispose(); } DeferredScalarObserver(Observer<? super R> actual); @Override void onSubscribe(Disposable s); @Override void onError(Throwable t); @Override void onComplete(); @Override ... | DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void dispose() { super.dispose(); s.dispose(); } DeferredScalarObserver(Observer<? super R> actual); @Override void onSubscribe(Disposable s); @Override void onError(Throwable t); @Override void onComplete(); @Override ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.