source.window(boundary).subscribe(wo);
source.window(boundary).subscribe(wo);
source.window(new Callable<Observable<Object>>() { @Override public Observable<Object> call() {
@Test public void exactOnError() { TestScheduler scheduler = new TestScheduler(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.window(1, 1, TimeUnit.SECONDS, scheduler) .flatMap(Functions.<Observable<Integer>>identity()) .test(); ps.onError(new TestException()); to.assertFailure(TestException.class); }
@Test public void overlappingOnError() { TestScheduler scheduler = new TestScheduler(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.window(2, 1, TimeUnit.SECONDS, scheduler) .flatMap(Functions.<Observable<Integer>>identity()) .test(); ps.onError(new TestException()); to.assertFailure(TestException.class); }
@Test public void skipOnError() { TestScheduler scheduler = new TestScheduler(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.window(1, 2, TimeUnit.SECONDS, scheduler) .flatMap(Functions.<Observable<Integer>>identity()) .test(); ps.onError(new TestException()); to.assertFailure(TestException.class); }
@Test public void testUnsubscribeAll() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> open = PublishSubject.create(); final PublishSubject<Integer> close = PublishSubject.create(); TestObserver<Observable<Integer>> to = new TestObserver<Observable<Integer>>(); source.window(open, new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer t) { return close; } }).subscribe(to); open.onNext(1); assertTrue(open.hasObservers()); assertTrue(close.hasObservers()); to.dispose(); // FIXME subject has subscribers because of the open window assertTrue(open.hasObservers()); // FIXME subject has subscribers because of the open window assertTrue(close.hasObservers()); }
@Test public void testBoundaryUnsubscribedOnMainCompletion() { PublishSubject<Integer> source = PublishSubject.create(); final PublishSubject<Integer> boundary = PublishSubject.create(); Callable<Observable<Integer>> boundaryFunc = new Callable<Observable<Integer>>() { @Override public Observable<Integer> call() { return boundary; } }; TestObserver<Observable<Integer>> to = new TestObserver<Observable<Integer>>(); source.window(boundaryFunc).subscribe(to); assertTrue(source.hasObservers()); assertTrue(boundary.hasObservers()); source.onComplete(); assertFalse(source.hasObservers()); assertFalse(boundary.hasObservers()); to.assertComplete(); to.assertNoErrors(); to.assertValueCount(1); }
@Test public void testMainUnsubscribedOnBoundaryCompletion() { PublishSubject<Integer> source = PublishSubject.create(); final PublishSubject<Integer> boundary = PublishSubject.create(); Callable<Observable<Integer>> boundaryFunc = new Callable<Observable<Integer>>() { @Override public Observable<Integer> call() { return boundary; } }; TestObserver<Observable<Integer>> to = new TestObserver<Observable<Integer>>(); source.window(boundaryFunc).subscribe(to); assertTrue(source.hasObservers()); assertTrue(boundary.hasObservers()); boundary.onComplete(); assertFalse(source.hasObservers()); assertFalse(boundary.hasObservers()); to.assertComplete(); to.assertNoErrors(); to.assertValueCount(1); }
@Test public void testChildUnsubscribed() { PublishSubject<Integer> source = PublishSubject.create(); final PublishSubject<Integer> boundary = PublishSubject.create(); Callable<Observable<Integer>> boundaryFunc = new Callable<Observable<Integer>>() { @Override public Observable<Integer> call() { return boundary; } }; TestObserver<Observable<Integer>> to = new TestObserver<Observable<Integer>>(); source.window(boundaryFunc).subscribe(to); assertTrue(source.hasObservers()); assertTrue(boundary.hasObservers()); to.dispose(); assertTrue(source.hasObservers()); assertFalse(boundary.hasObservers()); to.values().get(0).test(true); assertFalse(source.hasObservers()); to.assertNotComplete(); to.assertNoErrors(); to.assertValueCount(1); }
@Test public void upstreamDisposedWhenOutputsDisposed() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> boundary = PublishSubject.create(); TestObserver<Integer> to = source.window(boundary) .take(1) .flatMap(new Function<Observable<Integer>, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply( Observable<Integer> w) throws Exception { return w.take(1); } }) .test(); source.onNext(1); assertFalse("source not disposed", source.hasObservers()); assertFalse("boundary not disposed", boundary.hasObservers()); to.assertResult(1); }
@Test public void selectorUpstreamDisposedWhenOutputsDisposed() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> boundary = PublishSubject.create(); TestObserver<Integer> to = source.window(Functions.justCallable(boundary)) .take(1) .flatMap(new Function<Observable<Integer>, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply( Observable<Integer> w) throws Exception { return w.take(1); } }) .test(); source.onNext(1); assertFalse("source not disposed", source.hasObservers()); assertFalse("boundary not disposed", boundary.hasObservers()); to.assertResult(1); }
@Test public void startError() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> start = PublishSubject.create(); final PublishSubject<Integer> end = PublishSubject.create(); TestObserver<Integer> to = source.window(start, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) throws Exception { return end; } }) .flatMap(Functions.<Observable<Integer>>identity()) .test(); start.onError(new TestException()); to.assertFailure(TestException.class); assertFalse("Source has observers!", source.hasObservers()); assertFalse("Start has observers!", start.hasObservers()); assertFalse("End has observers!", end.hasObservers()); }
source.window(boundaryFunc).subscribe(to);
source.window(open, new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer t) {
@Test public void endError() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> start = PublishSubject.create(); final PublishSubject<Integer> end = PublishSubject.create(); TestObserver<Integer> to = source.window(start, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) throws Exception { return end; } }) .flatMap(Functions.<Observable<Integer>>identity()) .test(); start.onNext(1); end.onError(new TestException()); to.assertFailure(TestException.class); assertFalse("Source has observers!", source.hasObservers()); assertFalse("Start has observers!", start.hasObservers()); assertFalse("End has observers!", end.hasObservers()); }
@Test public void timeskipSkipping() { TestScheduler scheduler = new TestScheduler(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.window(1, 2, TimeUnit.SECONDS, scheduler) .flatMap(Functions.<Observable<Integer>>identity()) .test(); ps.onNext(1); ps.onNext(2); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); ps.onNext(3); ps.onNext(4); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); ps.onNext(5); ps.onNext(6); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); ps.onNext(7); ps.onComplete(); to.assertResult(1, 2, 5, 6); }
@Test public void timeskipOverlapping() { TestScheduler scheduler = new TestScheduler(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.window(2, 1, TimeUnit.SECONDS, scheduler) .flatMap(Functions.<Observable<Integer>>identity()) .test(); ps.onNext(1); ps.onNext(2); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); ps.onNext(3); ps.onNext(4); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); ps.onNext(5); ps.onNext(6); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); ps.onNext(7); ps.onComplete(); to.assertResult(1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7); }
@Test public void boundarySelectorNormal() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> start = PublishSubject.create(); final PublishSubject<Integer> end = PublishSubject.create(); TestObserver<Integer> to = source.window(start, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) throws Exception { return end; } }) .flatMap(Functions.<Observable<Integer>>identity()) .test(); start.onNext(0); source.onNext(1); source.onNext(2); source.onNext(3); source.onNext(4); start.onNext(1); source.onNext(5); source.onNext(6); end.onNext(1); start.onNext(2); TestHelper.emit(source, 7, 8); to.assertResult(1, 2, 3, 4, 5, 5, 6, 6, 7, 8); }