@Test public void cancelOnArrival() { SingleSubject.create() .test(true) .assertEmpty(); }
@Test public void cancelOnArrival2() { SingleSubject<Integer> ss = SingleSubject.create(); ss.test(); ss .test(true) .assertEmpty(); }
@Test public void nullThrowable() { SingleSubject<Integer> ss = SingleSubject.create(); try { ss.onError(null); fail("No NullPointerException thrown"); } catch (NullPointerException ex) { assertEquals("onError called with null. Null values are generally not allowed in 2.x operators and sources.", ex.getMessage()); } ss.test().assertEmpty().cancel(); }
@Test public void nullValue() { SingleSubject<Integer> ss = SingleSubject.create(); try { ss.onSuccess(null); fail("No NullPointerException thrown"); } catch (NullPointerException ex) { assertEquals("onSuccess called with null. Null values are generally not allowed in 2.x operators and sources.", ex.getMessage()); } ss.test().assertEmpty().cancel(); }
@Test public void scalarSource() { SingleSubject<Integer> ss = SingleSubject.create(); TestObserver<Integer> to = Observable.just(1) .switchMapSingle(Functions.justFunction(ss)) .test(); assertTrue(ss.hasObservers()); to.assertEmpty(); ss.onSuccess(2); to.assertResult(2); } }
@Test public void untilSingleMainSuccess() { SingleSubject<Integer> main = SingleSubject.create(); SingleSubject<Integer> other = SingleSubject.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); main.onSuccess(1); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(1); }
@Test public void scalarEmptySource() { SingleSubject<Integer> ss = SingleSubject.create(); Observable.empty() .switchMapSingle(Functions.justFunction(ss)) .test() .assertResult(); assertFalse(ss.hasObservers()); }
@Test public void scalarEmptySource() { SingleSubject<Integer> ss = SingleSubject.create(); Observable.empty() .concatMapSingle(Functions.justFunction(ss)) .test() .assertResult(); assertFalse(ss.hasObservers()); }
@Test public void cancelOther() { SingleSubject<Object> other = SingleSubject.create(); TestObserver<Object> to = Observable.empty() .concatWith(other) .test(); assertTrue(other.hasObservers()); to.cancel(); assertFalse(other.hasObservers()); }
@Test public void cancelOther() { SingleSubject<Object> other = SingleSubject.create(); TestSubscriber<Object> ts = Flowable.empty() .concatWith(other) .test(); assertTrue(other.hasObservers()); ts.cancel(); assertFalse(other.hasObservers()); }
@Test public void onSubscribeDispose() { SingleSubject<Integer> ss = SingleSubject.create(); Disposable d = Disposables.empty(); ss.onSubscribe(d); assertFalse(d.isDisposed()); ss.onSuccess(1); d = Disposables.empty(); ss.onSubscribe(d); assertTrue(d.isDisposed()); }
@Test public void checkUnboundedInnerQueue() { SingleSubject<Integer> ss = SingleSubject.create(); @SuppressWarnings("unchecked") TestObserver<Integer> to = Observable .fromArray(ss, Single.just(2), Single.just(3), Single.just(4)) .concatMapSingle(Functions.<Single<Integer>>identity(), 2) .test(); to.assertEmpty(); ss.onSuccess(1); to.assertResult(1, 2, 3, 4); }
@Test public void cancel() { final PublishProcessor<Integer> pp = PublishProcessor.create(); final SingleSubject<Integer> cs = SingleSubject.create(); TestSubscriber<Integer> ts = pp.mergeWith(cs).test(); assertTrue(pp.hasSubscribers()); assertTrue(cs.hasObservers()); ts.cancel(); assertFalse(pp.hasSubscribers()); assertFalse(cs.hasObservers()); }
@Test public void untilPublisherOtherOnNext() { SingleSubject<Integer> main = SingleSubject.create(); PublishProcessor<Integer> other = PublishProcessor.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasSubscribers()); other.onNext(1); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasSubscribers()); to.assertFailure(CancellationException.class); }
@Test public void untilCompletableMainSuccess() { SingleSubject<Integer> main = SingleSubject.create(); CompletableSubject other = CompletableSubject.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); main.onSuccess(1); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(1); }
@Test public void untilPublisherDispose() { SingleSubject<Integer> main = SingleSubject.create(); PublishProcessor<Integer> other = PublishProcessor.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasSubscribers()); to.dispose(); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasSubscribers()); to.assertEmpty(); }
@Test public void untilPublisherMainSuccess() { SingleSubject<Integer> main = SingleSubject.create(); PublishProcessor<Integer> other = PublishProcessor.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasSubscribers()); main.onSuccess(1); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasSubscribers()); to.assertResult(1); }
@Test public void untilPublisherMainError() { SingleSubject<Integer> main = SingleSubject.create(); PublishProcessor<Integer> other = PublishProcessor.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasSubscribers()); main.onError(new TestException()); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasSubscribers()); to.assertFailure(TestException.class); }
@Test public void untilPublisherOtherError() { SingleSubject<Integer> main = SingleSubject.create(); PublishProcessor<Integer> other = PublishProcessor.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasSubscribers()); other.onError(new TestException()); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasSubscribers()); to.assertFailure(TestException.class); }
@Test public void untilCompletableOtherError() { SingleSubject<Integer> main = SingleSubject.create(); CompletableSubject other = CompletableSubject.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); other.onError(new TestException()); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertFailure(TestException.class); }