@Ignore("No longer allowed") @Test public void testNullEmitting() throws Exception { // FIXME this is no longer allowed Observable<Boolean> nullObservable = BehaviorSubject.createDefault((Boolean) null); Observable<Boolean> nonNullObservable = BehaviorSubject.createDefault(true); Observable<Boolean> combined = combineLatest(nullObservable, nonNullObservable, new BiFunction<Boolean, Boolean, Boolean>() { @Override public Boolean apply(Boolean bool1, Boolean bool2) { return bool1 == null ? null : bool2; } }); combined.subscribe(new Consumer<Boolean>() { @Override public void accept(Boolean aBoolean) { Assert.assertNull(aBoolean); } }); } }
@Test public void testSubscribeToCompletedOnlyEmitsOnComplete() { BehaviorSubject<String> subject = BehaviorSubject.createDefault("default"); subject.onNext("one"); subject.onComplete(); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); verify(observer, never()).onNext("default"); verify(observer, never()).onNext("one"); verify(observer, Mockito.never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testSubscribeThenOnComplete() { BehaviorSubject<String> subject = BehaviorSubject.createDefault("default"); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("one"); subject.onComplete(); verify(observer, times(1)).onNext("default"); verify(observer, times(1)).onNext("one"); verify(observer, Mockito.never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testSubscribeToErrorOnlyEmitsOnError() { BehaviorSubject<String> subject = BehaviorSubject.createDefault("default"); subject.onNext("one"); RuntimeException re = new RuntimeException("test error"); subject.onError(re); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); verify(observer, never()).onNext("default"); verify(observer, never()).onNext("one"); verify(observer, times(1)).onError(re); verify(observer, never()).onComplete(); }
@Test public void testThatSubscriberReceivesDefaultValueAndSubsequentEvents() { BehaviorSubject<String> subject = BehaviorSubject.createDefault("default"); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("one"); subject.onNext("two"); subject.onNext("three"); verify(observer, times(1)).onNext("default"); verify(observer, times(1)).onNext("one"); verify(observer, times(1)).onNext("two"); verify(observer, times(1)).onNext("three"); verify(observer, Mockito.never()).onError(testException); verify(observer, Mockito.never()).onComplete(); }
@Test public void testThatSubscriberReceivesLatestAndThenSubsequentEvents() { BehaviorSubject<String> subject = BehaviorSubject.createDefault("default"); subject.onNext("one"); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("two"); subject.onNext("three"); verify(observer, Mockito.never()).onNext("default"); verify(observer, times(1)).onNext("one"); verify(observer, times(1)).onNext("two"); verify(observer, times(1)).onNext("three"); verify(observer, Mockito.never()).onError(testException); verify(observer, Mockito.never()).onComplete(); }
@Test public void testCompletedAfterErrorIsNotSent() { BehaviorSubject<String> subject = BehaviorSubject.createDefault("default"); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("one"); subject.onError(testException); subject.onNext("two"); subject.onComplete(); verify(observer, times(1)).onNext("default"); verify(observer, times(1)).onNext("one"); verify(observer, times(1)).onError(testException); verify(observer, never()).onNext("two"); verify(observer, never()).onComplete(); }
@Test public void testTakeOneSubscriber() { BehaviorSubject<Integer> source = BehaviorSubject.createDefault(1); final Observer<Object> o = TestHelper.mockObserver(); source.take(1).subscribe(o); verify(o).onNext(1); verify(o).onComplete(); verify(o, never()).onError(any(Throwable.class)); assertEquals(0, source.subscriberCount()); assertFalse(source.hasObservers()); }
@Test public void testCompletedAfterErrorIsNotSent3() { BehaviorSubject<String> subject = BehaviorSubject.createDefault("default"); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("one"); subject.onComplete(); subject.onNext("two"); subject.onComplete(); verify(observer, times(1)).onNext("default"); verify(observer, times(1)).onNext("one"); verify(observer, times(1)).onComplete(); verify(observer, never()).onError(any(Throwable.class)); verify(observer, never()).onNext("two"); Observer<Object> o2 = TestHelper.mockObserver(); subject.subscribe(o2); verify(o2, times(1)).onComplete(); verify(o2, never()).onNext(any()); verify(observer, never()).onError(any(Throwable.class)); }
@Test public void testCompletedAfterErrorIsNotSent2() { BehaviorSubject<String> subject = BehaviorSubject.createDefault("default"); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("one"); subject.onError(testException); subject.onNext("two"); subject.onComplete(); verify(observer, times(1)).onNext("default"); verify(observer, times(1)).onNext("one"); verify(observer, times(1)).onError(testException); verify(observer, never()).onNext("two"); verify(observer, never()).onComplete(); Observer<Object> o2 = TestHelper.mockObserver(); subject.subscribe(o2); verify(o2, times(1)).onError(testException); verify(o2, never()).onNext(any()); verify(o2, never()).onComplete(); }
@Test public void outputFusedOneSignal() { final BehaviorSubject<Integer> bs = BehaviorSubject.createDefault(1); bs.observeOn(ImmediateThinScheduler.INSTANCE) .concatMap(new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) throws Exception { return Observable.just(v + 1); } }) .subscribeWith(new TestObserver<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); if (t == 2) { bs.onNext(2); } } }) .assertValuesOnly(2, 3); }
@Test public void boundaryCallableCrashOnCall2() { BehaviorSubject.createDefault(1) .window(new Callable<Observable<Integer>>() { int calls; @Override public Observable<Integer> call() throws Exception { if (++calls == 2) { throw new TestException(); } return Observable.just(1); } }) .test() .assertError(TestException.class) .assertNotComplete(); }
@Test(timeout = 7500) public void blockingSourceAsnycCancel() throws Exception { BehaviorSubject<Integer> bs = BehaviorSubject.createDefault(1); Observable<Integer> o = bs .replay(1) .refCount(); o.subscribe(); final AtomicBoolean interrupted = new AtomicBoolean(); o.switchMap(new Function<Integer, ObservableSource<? extends Object>>() { @Override public ObservableSource<? extends Object> apply(Integer v) throws Exception { return Observable.create(new ObservableOnSubscribe<Object>() { @Override public void subscribe(ObservableEmitter<Object> emitter) throws Exception { while (!emitter.isDisposed()) { Thread.sleep(100); } interrupted.set(true); } }); } }) .take(500, TimeUnit.MILLISECONDS) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(); assertTrue(interrupted.get()); }
@Test public void disposeInOnNext() { final TestObserver<Integer> to = new TestObserver<Integer>(); BehaviorSubject.createDefault(1) .debounce(new Function<Integer, ObservableSource<Object>>() { @Override public ObservableSource<Object> apply(Integer o) throws Exception { to.cancel(); return Observable.never(); } }) .subscribeWith(to) .assertEmpty(); assertTrue(to.isDisposed()); }
@Test public void reentrant() { final Subject<Integer> ps = PublishSubject.<Integer>create(); TestObserver<Integer> to = new TestObserver<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); if (t == 1) { ps.onNext(2); ps.onComplete(); } } }; ps.window(BehaviorSubject.createDefault(1), Functions.justFunction(Observable.never())) .flatMap(new Function<Observable<Integer>, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Observable<Integer> v) throws Exception { return v; } }) .subscribe(to); ps.onNext(1); to .awaitDone(1, TimeUnit.SECONDS) .assertResult(1, 2); }
@Test public void boundaryError() { BehaviorSubject.createDefault(1) .window(Functions.justCallable(Observable.error(new TestException()))) .test() .assertValueCount(1) .assertNotComplete() .assertError(TestException.class); }
@Test public void oneWindow() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Observable<Integer>> to = BehaviorSubject.createDefault(1) .window(Functions.justCallable(ps)) .take(1) .test(); ps.onNext(1); to .assertValueCount(1) .assertNoErrors() .assertComplete(); }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void subscribeOnNextRace() { for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { final BehaviorSubject<Object> p = BehaviorSubject.createDefault((Object)1); final TestObserver[] to = { null }; Runnable r1 = new Runnable() { @Override public void run() { to[0] = p.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { p.onNext(2); } }; TestHelper.race(r1, r2); if (to[0].valueCount() == 1) { to[0].assertValue(2).assertNoErrors().assertNotComplete(); } else { to[0].assertValues(1, 2).assertNoErrors().assertNotComplete(); } } }
@Test public void bufferBoundaryErrorTwice() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { BehaviorSubject.createDefault(1) .buffer(Functions.justCallable(new Observable<Integer>() { @Override protected void subscribeActual(Observer<? super Integer> observer) { observer.onSubscribe(Disposables.empty()); observer.onError(new TestException("first")); observer.onError(new TestException("second")); } })) .test() .assertError(TestException.class) .assertErrorMessage("first") .assertNotComplete(); TestHelper.assertUndeliverable(errors, 0, TestException.class, "second"); } finally { RxJavaPlugins.reset(); } }
@Test public void testCurrentStateMethodsNormalSomeStart() { BehaviorSubject<Object> as = BehaviorSubject.createDefault((Object)1); assertTrue(as.hasValue()); assertFalse(as.hasThrowable()); assertFalse(as.hasComplete()); assertEquals(1, as.getValue()); assertNull(as.getThrowable()); as.onNext(2); assertTrue(as.hasValue()); assertFalse(as.hasThrowable()); assertFalse(as.hasComplete()); assertEquals(2, as.getValue()); assertNull(as.getThrowable()); as.onComplete(); assertFalse(as.hasValue()); assertFalse(as.hasThrowable()); assertTrue(as.hasComplete()); assertNull(as.getValue()); assertNull(as.getThrowable()); }