SpscLinkedArrayQueue<R> getOrCreateQueue() { for (;;) { SpscLinkedArrayQueue<R> current = queue.get(); if (current != null) { return current; } current = new SpscLinkedArrayQueue<R>(Observable.bufferSize()); if (queue.compareAndSet(null, current)) { return current; } } }
@Override public ObservableSource<? extends R> apply(List<ObservableSource<? extends T>> list) { return Observable.zipIterable(list, zipper, false, Observable.bufferSize()); } }
SpscLinkedArrayQueue<R> getOrCreateQueue() { for (;;) { SpscLinkedArrayQueue<R> current = queue.get(); if (current != null) { return current; } current = new SpscLinkedArrayQueue<R>(Observable.bufferSize()); if (queue.compareAndSet(null, current)) { return current; } } }
SpscLinkedArrayQueue<R> getOrCreateQueue() { for (;;) { SpscLinkedArrayQueue<R> current = queue.get(); if (current != null) { return current; } current = new SpscLinkedArrayQueue<R>(Observable.bufferSize()); if (queue.compareAndSet(null, current)) { return current; } } }
SpscLinkedArrayQueue<R> getOrCreateQueue() { for (;;) { SpscLinkedArrayQueue<R> current = queue.get(); if (current != null) { return current; } current = new SpscLinkedArrayQueue<R>(Observable.bufferSize()); if (queue.compareAndSet(null, current)) { return current; } } }
@Override public ObservableSource<? extends R> apply(List<ObservableSource<? extends T>> list) { return Observable.zipIterable(list, zipper, false, Observable.bufferSize()); } }
@Test public void testNoBackpressure() { ArrayList<Long> list = new ArrayList<Long>(Observable.bufferSize() * 2); for (long i = 1; i <= Observable.bufferSize() * 2 + 1; i++) { list.add(i); } Observable<Long> o = Observable.rangeLong(1, list.size()); TestObserver<Long> ts = new TestObserver<Long>(); o.subscribe(ts); ts.assertValueSequence(list); ts.assertTerminated(); }
@Test public void testNoBackpressure() { ArrayList<Integer> list = new ArrayList<Integer>(Observable.bufferSize() * 2); for (int i = 1; i <= Observable.bufferSize() * 2 + 1; i++) { list.add(i); } Observable<Integer> o = Observable.range(1, list.size()); TestObserver<Integer> ts = new TestObserver<Integer>(); o.subscribe(ts); ts.assertValueSequence(list); ts.assertTerminated(); }
@Test public void onTerminateCalledWhenOnError() { final AtomicBoolean didRunOnTerminate = new AtomicBoolean(); UnicastSubject<Integer> us = UnicastSubject.create(Observable.bufferSize(), new Runnable() { @Override public void run() { didRunOnTerminate.set(true); } }); assertEquals(false, didRunOnTerminate.get()); us.onError(new RuntimeException("some error")); assertEquals(true, didRunOnTerminate.get()); }
@Test public void onTerminateCalledWhenOnComplete() { final AtomicBoolean didRunOnTerminate = new AtomicBoolean(); UnicastSubject<Integer> us = UnicastSubject.create(Observable.bufferSize(), new Runnable() { @Override public void run() { didRunOnTerminate.set(true); } }); assertEquals(false, didRunOnTerminate.get()); us.onComplete(); assertEquals(true, didRunOnTerminate.get()); }
@Override public Observable<Integer> apply(Integer t) { return Observable.range(1, Observable.bufferSize() * 2) .doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); } }).subscribe(ts);
@Test public void onTerminateCalledWhenCanceled() { final AtomicBoolean didRunOnTerminate = new AtomicBoolean(); UnicastSubject<Integer> us = UnicastSubject.create(Observable.bufferSize(), new Runnable() { @Override public void run() { didRunOnTerminate.set(true); } }); final Disposable subscribe = us.subscribe(); assertEquals(false, didRunOnTerminate.get()); subscribe.dispose(); assertEquals(true, didRunOnTerminate.get()); }
@Test(expected = IllegalArgumentException.class) public void testInvalidMaxConcurrent() { Observable.just(1).concatMapEager(toJust, 0, Observable.bufferSize()); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCapacityHint() { Observable.just(1).concatMapEager(toJust, Observable.bufferSize(), 0); }
@Test public void testSkipLastWithBackpressure() { Observable<Integer> o = Observable.range(0, Observable.bufferSize() * 2).skipLast(Observable.bufferSize() + 10); TestObserver<Integer> ts = new TestObserver<Integer>(); o.observeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals((Observable.bufferSize()) - 10, ts.valueCount()); }
@Test public void longEager() { Observable.range(1, 2 * Observable.bufferSize()) .concatMapEager(new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) { return Observable.just(1); } }) .test() .assertValueCount(2 * Observable.bufferSize()) .assertNoErrors() .assertComplete(); }
@Test public void mergeALot() { @SuppressWarnings("unchecked") Maybe<Integer>[] sources = new Maybe[Observable.bufferSize() * 2]; Arrays.fill(sources, Maybe.just(1)); Maybe.mergeArray(sources) .test() .assertSubscribed() .assertValueCount(sources.length) .assertNoErrors() .assertComplete(); }
@Test public void testBackpressure2() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable.range(1, 100000).takeLast(Observable.bufferSize() * 4) .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(Observable.bufferSize() * 4, ts.valueCount()); }
@Test public void mergeALotLastEmpty() { @SuppressWarnings("unchecked") Maybe<Integer>[] sources = new Maybe[Observable.bufferSize() * 2]; Arrays.fill(sources, Maybe.just(1)); sources[sources.length - 1] = Maybe.empty(); Maybe.mergeArray(sources) .test() .assertSubscribed() .assertValueCount(sources.length - 1) .assertNoErrors() .assertComplete(); }
@Test public void testTakeUntilWithPublishedStream() { Observable<Integer> xs = Observable.range(0, Observable.bufferSize() * 2); TestObserver<Integer> ts = new TestObserver<Integer>(); ConnectableObservable<Integer> xsp = xs.publish(); xsp.takeUntil(xsp.skipWhile(new Predicate<Integer>() { @Override public boolean test(Integer i) { return i <= 3; } })).subscribe(ts); xsp.connect(); System.out.println(ts.values()); }