public void testAdd_firstFewWithSuccess() { final int COUNT = 400; when(backingMap.get(KEY)).thenReturn(null); when(backingMap.putIfAbsent(eq(KEY), isA(AtomicInteger.class))).thenReturn(null); assertEquals(0, multiset.add(KEY, COUNT)); }
@Test public void testSingleOrDefaultWithTooManyElements() { Single<Integer> o = Observable.just(1, 2).single(3); SingleObserver<Integer> observer = TestHelper.mockSingleObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleWithTooManyElementsObservable() { Observable<Integer> o = Observable.just(1, 2).singleElement().toObservable(); Observer<Integer> observer = TestHelper.mockObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithTooManyElementsObservable() { Observable<Integer> o = Observable.just(1, 2).single(3).toObservable(); Observer<Integer> observer = TestHelper.mockObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testFirstOfNone() { Flowable<Integer> flowable = Flowable.empty(); flowable.firstElement().subscribe(wm); verify(wm, never()).onSuccess(anyInt()); verify(wm).onComplete(); verify(wm, never()).onError(isA(NoSuchElementException.class)); }
@Test public void testFirstWithPredicateOfNoneMatchingThePredicate() { Flowable<Integer> flowable = Flowable.just(1, 3, 5, 7, 9, 7, 5, 3, 1); flowable.filter(IS_EVEN).firstElement().subscribe(wm); verify(wm, never()).onSuccess(anyInt()); verify(wm, times(1)).onComplete(); verify(wm, never()).onError(isA(NoSuchElementException.class)); }
@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 testSingleWithTooManyElements() { Maybe<Integer> o = Observable.just(1, 2).singleElement(); MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithPredicateAndTooManyElements() { Single<Integer> o = Observable.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(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleOrDefaultWithPredicateAndTooManyElementsObservable() { Observable<Integer> o = Observable.just(1, 2, 3, 4) .filter(new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .single(6).toObservable(); Observer<Integer> observer = TestHelper.mockObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleWithTooManyElements() { Maybe<Integer> maybe = Flowable.just(1, 2).singleElement(); MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver(); maybe.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleWithPredicateAndTooManyElementsObservable() { Observable<Integer> o = Observable.just(1, 2, 3, 4) .filter( new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .singleElement().toObservable(); Observer<Integer> observer = TestHelper.mockObserver(); o.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); 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 testSingleWithTooManyElementsFlowable() { Flowable<Integer> flowable = Flowable.just(1, 2).singleElement().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 testTimeoutSelectorWithFirstTimeoutFirstAndNoOtherObservable() { PublishSubject<Integer> source = PublishSubject.create(); final PublishSubject<Integer> timeout = PublishSubject.create(); Function<Integer, Observable<Integer>> timeoutFunc = new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer t1) { return PublishSubject.create(); } }; Observer<Object> o = TestHelper.mockObserver(); source.timeout(timeout, timeoutFunc).subscribe(o); timeout.onNext(1); InOrder inOrder = inOrder(o); inOrder.verify(o).onError(isA(TimeoutException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleWithPredicateAndTooManyElements() { Maybe<Integer> maybe = Flowable.just(1, 2, 3, 4) .filter( new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .singleElement(); MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver(); maybe.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@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 testSingleWithPredicateAndTooManyElementsFlowable() { Flowable<Integer> flowable = Flowable.just(1, 2, 3, 4) .filter( new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .singleElement().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 testTimeoutSelectorWithFirstTimeoutFirstAndNoOtherFlowable() { PublishProcessor<Integer> source = PublishProcessor.create(); final PublishProcessor<Integer> timeout = PublishProcessor.create(); Function<Integer, Flowable<Integer>> timeoutFunc = new Function<Integer, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Integer t1) { return PublishProcessor.create(); } }; Subscriber<Object> subscriber = TestHelper.mockSubscriber(); source.timeout(timeout, timeoutFunc).subscribe(subscriber); timeout.onNext(1); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber).onError(isA(TimeoutException.class)); inOrder.verifyNoMoreInteractions(); }