@Override public void onNext(T v) { onNext(v, innerScheduler.now()); }
@Test public void cancelShouldUnsubscribe() { TestSubject<String> single = TestSubject.create(new TestScheduler()); assertFalse(single.hasObservers()); T future = toFuture(single.toSingle()); assertTrue(single.hasObservers()); future.cancel(true); assertFalse(single.hasObservers()); }
@Override public void onCompleted() { onCompleted(innerScheduler.now()); }
@Before public void setUp() throws Exception { mLifecycleScheduler = new TestScheduler(); mLifecycleSubject = TestSubject.create(mLifecycleScheduler); mEventScheduler = new TestScheduler(); mEventSubject = TestSubject.create(mEventScheduler); mTestHost = new TestHost(mEventSubject.asObservable(), mLifecycleSubject.asObservable()); }
@Test public void testExpectedReplayBehavior() { final TestScheduler scheduler = new TestScheduler(); final TestSubject<Integer> subject = TestSubject.create(scheduler); final TestSubscriber<Integer> subscriber = new TestSubscriber<>(); final ConnectableObservable<Integer> sums = subject.scan((a, b) -> a + b).replay(1); sums.connect(); subject.onNext(1); subject.onNext(2); subject.onNext(3); scheduler.triggerActions(); sums.subscribe(subscriber); subscriber.assertValueCount(1); subscriber.assertValues(6); }
@SuppressWarnings("unchecked") @Test public void multipleLeftTerminalRightOtherThread() { TestScheduler otherScheduler = Schedulers.test(); TestSubject<EventB> eventBSubject = TestSubject.create(otherScheduler); Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject); either.subscribe(subscriber); eventASubject.onNext(eventA); eventBSubject.onNext(eventB); eventBSubject.onCompleted(); eventASubject.onNext(eventA); testScheduler.triggerActions(); subscriber.assertNotCompleted(); otherScheduler.triggerActions(); subscriber.assertNoErrors(); subscriber.assertCompleted(); subscriber.assertUnsubscribed(); subscriber.assertValues(Either.<EventA, EventB>left(eventA), Either.<EventA, EventB>left(eventA), Either.<EventA, EventB>right(eventB)); }
@SuppressWarnings("unchecked") @Test public void singleLeftTerminalRight() { Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject); either.subscribe(subscriber); eventASubject.onNext(eventA); eventBSubject.onNext(eventB); eventBSubject.onCompleted(); eventASubject.onNext(eventA); testScheduler.triggerActions(); subscriber.assertNoErrors(); subscriber.assertCompleted(); subscriber.assertUnsubscribed(); subscriber.assertValues(Either.<EventA, EventB>left(eventA), Either.<EventA, EventB>right(eventB)); }
@Test public void errorLeftBlockRight() { Throwable error = new Throwable(); Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject); either.subscribe(subscriber); eventASubject.onError(error); eventBSubject.onNext(eventB); testScheduler.triggerActions(); subscriber.assertError(error); subscriber.assertNotCompleted(); subscriber.assertUnsubscribed(); subscriber.assertNoValues(); }
@Override public void onError(final Throwable e) { onError(e, innerScheduler.now()); }
/** * Creates and returns a new {@code TestSubject}. * * @param <T> the value type * @param scheduler a {@link TestScheduler} on which to operate this Subject * @return the new {@code TestSubject} */ public static <T> TestSubject<T> create(TestScheduler scheduler) { final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager<T>(); state.onAdded = new Action1<SubjectObserver<T>>() { @Override public void call(SubjectObserver<T> o) { o.emitFirst(state.get(), state.nl); } }; state.onTerminated = state.onAdded; return new TestSubject<T>(state, state, scheduler); }
@Test public void testFlakyReplayBehavior() { final TestScheduler scheduler = new TestScheduler(); final TestSubject<Integer> subject = TestSubject.create(scheduler); final TestSubscriber<Integer> subscriber = new TestSubscriber<>(); final ConnectableObservable<Integer> sums = subject.scan(1, (a, b) -> a + b).replay(1); sums.connect(); subject.onNext(2); subject.onNext(3); scheduler.triggerActions(); sums.subscribe(subscriber); // subscriber.assertValueCount(1); subscriber.assertValues(6); }
@Test @SuppressWarnings("unchecked") public void continuedLazy() { Action1<EventA> eventAAction = mock(Action1.class); Action1<EventB> eventBAction = mock(Action1.class); Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject); either.subscribe(RxEither.continuedLazy(eventAAction, eventBAction)); eventASubject.onNext(eventA); eventBSubject.onNext(eventB); testScheduler.triggerActions(); verify(eventAAction).call(eventA); verify(eventBAction).call(eventB); }
@Test @SuppressWarnings({"unchecked", "deprecation"}) public void foldLazyFunc() { Action1<EventA> eventAAction = mock(Action1.class); Func1<EventA, EventA> eventAEventAFunc = mock(Func1.class); Func1<EventB, EventA> eventBEventAFunc = mock(Func1.class); when(eventAEventAFunc.call(eventA)).thenReturn(eventA); when(eventBEventAFunc.call(eventB)).thenReturn(eventA); Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject); either.map(RxEither.foldLazy(eventAEventAFunc, eventBEventAFunc)).subscribe(eventAAction); eventASubject.onNext(eventA); eventBSubject.onNext(eventB); testScheduler.triggerActions(); verify(eventAAction, times(2)).call(eventA); }
@Test public void bundleContainsIds() { mLifecycleSubject.onNext(new LifecycleEvent.InitEvent(null)); mLifecycleSubject.onNext(new LifecycleEvent.ResumeEvent()); mLifecycleScheduler.triggerActions(); mTestHost.composeObservable(); Bundle state = new Bundle(); mLifecycleSubject.onNext(new LifecycleEvent.PauseEvent()); mLifecycleSubject.onNext(new LifecycleEvent.SaveStateEvent(state)); mLifecycleScheduler.triggerActions(); assertFalse(state.isEmpty()); }
@Test @SuppressWarnings({"unchecked", "deprecation"}) public void foldLazyAction() { Action1<EventA> eventAAction = mock(Action1.class); Action1<EventB> eventBAction = mock(Action1.class); Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject); either.subscribe(RxEither.foldLazy(eventAAction, eventBAction)); eventASubject.onNext(eventA); eventBSubject.onNext(eventB); testScheduler.triggerActions(); verify(eventAAction).call(eventA); verify(eventBAction).call(eventB); }
@Test @SuppressWarnings("unchecked") public void joinLazy() { Action1<EventA> eventAAction = mock(Action1.class); Func1<EventA, EventA> eventAEventAFunc = mock(Func1.class); Func1<EventB, EventA> eventBEventAFunc = mock(Func1.class); when(eventAEventAFunc.call(eventA)).thenReturn(eventA); when(eventBEventAFunc.call(eventB)).thenReturn(eventA); Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject); either.map(RxEither.joinLazy(eventAEventAFunc, eventBEventAFunc)).subscribe(eventAAction); eventASubject.onNext(eventA); eventBSubject.onNext(eventB); testScheduler.triggerActions(); verify(eventAAction, times(2)).call(eventA); } }
@Test public void receivesEvents() { mLifecycleSubject.onNext(new LifecycleEvent.InitEvent(null)); mLifecycleSubject.onNext(new LifecycleEvent.ResumeEvent()); mLifecycleScheduler.triggerActions(); mTestHost.composeObservable(); mEventSubject.onNext(1); mEventScheduler.triggerActions(); mTestHost.getTestSubscriber().assertReceivedOnNext(Collections.singletonList(1)); }
@Test public void doesNotReceiveEventsAfterPause() { mLifecycleSubject.onNext(new LifecycleEvent.InitEvent(null)); mLifecycleSubject.onNext(new LifecycleEvent.ResumeEvent()); mLifecycleScheduler.triggerActions(); mTestHost.composeObservable(); mLifecycleSubject.onNext(new LifecycleEvent.PauseEvent()); mLifecycleScheduler.triggerActions(); mEventSubject.onNext(2); mEventScheduler.triggerActions(); mTestHost.getTestSubscriber().assertValueCount(0); }
@SuppressWarnings("unchecked") @Test public void multipleLeftRight() { Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject); either.subscribe(subscriber); eventASubject.onNext(eventA); eventBSubject.onNext(eventB); eventBSubject.onNext(eventB); eventASubject.onNext(eventA); testScheduler.triggerActions(); subscriber.assertNoErrors(); subscriber.assertNotCompleted(); subscriber.assertValues(Either.<EventA, EventB>left(eventA), Either.<EventA, EventB>right(eventB), Either.<EventA, EventB>right(eventB), Either.<EventA, EventB>left(eventA)); }