@Test(expected = NullPointerException.class) public void singleNull() { just1.single(null); }
@Test public void testSingleOrDefault() { Single<Integer> single = Flowable.just(1).single(2); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(1); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithEmpty() { Single<Integer> single = Flowable.<Integer> empty() .single(1); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(1); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithTooManyElements() { Single<Integer> single = Flowable.just(1, 2).single(3); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithEmptyFlowable() { Flowable<Integer> flowable = Flowable.<Integer> empty() .single(1).toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber, times(1)).onNext(1); inOrder.verify(subscriber, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultFlowable() { Flowable<Integer> flowable = Flowable.just(1).single(2).toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber, times(1)).onNext(1); inOrder.verify(subscriber, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithPredicate() { Single<Integer> single = Flowable.just(1, 2) .filter(new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .single(4); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(2); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithPredicateAndEmpty() { Single<Integer> single = Flowable.just(1) .filter(new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .single(2); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(2); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithPredicateAndTooManyElements() { Single<Integer> single = Flowable.just(1, 2, 3, 4) .filter(new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .single(6); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); single.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithTooManyElementsFlowable() { Flowable<Integer> flowable = Flowable.just(1, 2).single(3).toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithPredicateFlowable() { Flowable<Integer> flowable = Flowable.just(1, 2) .filter(new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .single(4).toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber, times(1)).onNext(2); inOrder.verify(subscriber, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithPredicateAndEmptyFlowable() { Flowable<Integer> flowable = Flowable.just(1) .filter(new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .single(2).toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber, times(1)).onNext(2); inOrder.verify(subscriber, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void testErrorObservable() { TestSubscriber<String> subscriber = TestSubscriber.create(); IllegalArgumentException error = new IllegalArgumentException("Error"); Single<String> single = Flowable.<String>error(error).single(""); single.toFlowable().subscribe(subscriber); subscriber.assertError(error); }
@Test public void testShouldUseUnsafeSubscribeInternallyNotSubscribe() { TestSubscriber<String> subscriber = TestSubscriber.create(); final AtomicBoolean unsubscribed = new AtomicBoolean(false); Single<String> single = Flowable.just("Hello World!").doOnCancel(new Action() { @Override public void run() { unsubscribed.set(true); }}).single(""); single.toFlowable().subscribe(subscriber); subscriber.assertComplete(); Assert.assertFalse(unsubscribed.get()); } }
@Test public void testSingleOrDefaultWithPredicateAndTooManyElementsFlowable() { Flowable<Integer> flowable = Flowable.just(1, 2, 3, 4) .filter(new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .single(6).toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void normal() throws Exception { PublishProcessor<Integer> pp = PublishProcessor.create(); final String[] name = { null }; final CountDownLatch cdl = new CountDownLatch(1); pp.doOnCancel(new Action() { @Override public void run() throws Exception { name[0] = Thread.currentThread().getName(); cdl.countDown(); } }) .single(-99) .unsubscribeOn(Schedulers.single()) .test(true) ; assertTrue(cdl.await(5, TimeUnit.SECONDS)); int times = 10; while (times-- > 0 && pp.hasSubscribers()) { Thread.sleep(100); } assertFalse(pp.hasSubscribers()); assertNotEquals(Thread.currentThread().getName(), name[0]); }
@Test public void testJustTwoEmissionsObservableThrowsError() { TestSubscriber<String> subscriber = TestSubscriber.create(); Single<String> single = Flowable.just("First", "Second").single(""); single.toFlowable().subscribe(subscriber); subscriber.assertError(IllegalArgumentException.class); }
@Test public void testEmptyObservable() { TestSubscriber<String> subscriber = TestSubscriber.create(); Single<String> single = Flowable.<String>empty().single(""); single.toFlowable().subscribe(subscriber); subscriber.assertResult(""); }
@Test public void testJustSingleItemObservable() { TestSubscriber<String> subscriber = TestSubscriber.create(); Single<String> single = Flowable.just("Hello World!").single(""); single.toFlowable().subscribe(subscriber); subscriber.assertResult("Hello World!"); }
@Test public void testRepeatObservableThrowsError() { TestSubscriber<String> subscriber = TestSubscriber.create(); Single<String> single = Flowable.just("First", "Second").repeat().single(""); single.toFlowable().subscribe(subscriber); subscriber.assertError(IllegalArgumentException.class); }