@Override public Observable<Integer> apply(Observable<Integer> o) { return o.take(2); } });
@Test public void fromIterable() { ArrayList<String> items = new ArrayList<String>(); items.add("one"); items.add("two"); items.add("three"); assertEquals((Long)3L, Observable.fromIterable(items).count().blockingGet()); assertEquals("two", Observable.fromIterable(items).skip(1).take(1).blockingSingle()); assertEquals("three", Observable.fromIterable(items).takeLast(1).blockingSingle()); }
@Test public void fromArityArgs3() { Observable<String> items = Observable.just("one", "two", "three"); assertEquals((Long)3L, items.count().blockingGet()); assertEquals("two", items.skip(1).take(1).blockingSingle()); assertEquals("three", items.takeLast(1).blockingSingle()); }
@Test public void testTakeFirstOfNone() { Observable<Integer> o = Observable.empty(); o.take(1).subscribe(w); verify(w, never()).onNext(anyInt()); verify(w, times(1)).onComplete(); verify(w, never()).onError(any(Throwable.class)); }
@Test public void fromArray() { String[] items = new String[] { "one", "two", "three" }; assertEquals((Long)3L, Observable.fromArray(items).count().blockingGet()); assertEquals("two", Observable.fromArray(items).skip(1).take(1).blockingSingle()); assertEquals("three", Observable.fromArray(items).takeLast(1).blockingSingle()); }
@Test public void testTakeFirstOfSome() { Observable<Integer> o = Observable.just(1, 2, 3); o.take(1).subscribe(w); verify(w, times(1)).onNext(anyInt()); verify(w).onNext(1); verify(w, times(1)).onComplete(); verify(w, never()).onError(any(Throwable.class)); }
@Test public void testTakeFirstWithPredicateOfSome() { Observable<Integer> o = Observable.just(1, 3, 5, 4, 6, 3); o.filter(IS_EVEN).take(1).subscribe(w); verify(w, times(1)).onNext(anyInt()); verify(w).onNext(4); verify(w, times(1)).onComplete(); verify(w, never()).onError(any(Throwable.class)); }
@Test public void testWrappingMockWhenUnsubscribeInvolved() { Observable<Integer> oi = Observable.fromIterable(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9)).take(2); Observer<Integer> mockObserver = TestHelper.mockObserver(); oi.subscribe(new TestObserver<Integer>(mockObserver)); InOrder inOrder = inOrder(mockObserver); inOrder.verify(mockObserver, times(1)).onNext(1); inOrder.verify(mockObserver, times(1)).onNext(2); inOrder.verify(mockObserver, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test(timeout = 2000) public void testRepeatAndTake() { Observer<Object> o = TestHelper.mockObserver(); Observable.just(1).repeat().take(10).subscribe(o); verify(o, times(10)).onNext(1); verify(o).onComplete(); verify(o, never()).onError(any(Throwable.class)); }
@Test public void takeNegative() { try { Observable.just(1).take(-99); fail("Should have thrown"); } catch (IllegalArgumentException ex) { assertEquals("count >= 0 required but it was -99", ex.getMessage()); } }
@Test(timeout = 2000) public void bufferWithTimeTake1() { Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler); Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler).take(1); Observer<Object> o = TestHelper.mockObserver(); result.subscribe(o); scheduler.advanceTimeBy(5, TimeUnit.SECONDS); verify(o).onNext(Arrays.asList(0L, 1L)); verify(o).onComplete(); verify(o, never()).onError(any(Throwable.class)); } @Test(timeout = 2000)
@Override public Observable<String> apply(final String s) { return Observable.just(s) .mergeWith(Observable.interval(10, TimeUnit.MILLISECONDS) .map(new Function<Long, String>() { @Override public String apply(Long i) { return s + " " + i; } })).take(250); } })
@Test public void take() { Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() { @Override public Iterable<Integer> apply(Integer v) throws Exception { return Arrays.asList(v, v + 1); } }) .take(1) .test() .assertResult(1); }
@Test public void normalTake() { Observable.range(1, 10) .doFinally(this) .take(5) .test() .assertResult(1, 2, 3, 4, 5); assertEquals(1, calls); }
@Test public void take() { Observable.just(1) .skipLast(0, TimeUnit.SECONDS) .take(1) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1); } }
@Test public void normalTakeConditional() { Observable.range(1, 10) .doFinally(this) .filter(Functions.alwaysTrue()) .take(5) .test() .assertResult(1, 2, 3, 4, 5); assertEquals(1, calls); }
@Test public void merge4Take2() { Maybe.merge(Maybe.just(1), Maybe.just(2), Maybe.just(3), Maybe.just(4)) .take(2) .test() .assertResult(1, 2); }
@Test public void testTake() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable<Integer> cached = Observable.range(1, 100).replay().autoConnect(); cached.take(10).subscribe(ts); ts.assertNoErrors(); ts.assertTerminated(); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // FIXME no longer assertable // ts.assertUnsubscribed(); }
@Test public void timedTake() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.timeout(1, TimeUnit.DAYS) .take(1) .test(); assertTrue(ps.hasObservers()); ps.onNext(1); assertFalse(ps.hasObservers()); to.assertResult(1); }
@Test public void timedFallbackTake() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.timeout(1, TimeUnit.DAYS, Observable.just(2)) .take(1) .test(); assertTrue(ps.hasObservers()); ps.onNext(1); assertFalse(ps.hasObservers()); to.assertResult(1); } }