@Override public Flowable<Object> apply(Flowable<Object> f) throws Exception { return f.takeLast(5); } });
@Override public Publisher<Flowable<Object>> apply(Flowable<Object> f) throws Exception { return f.window(1, TimeUnit.SECONDS, 1).takeLast(0); } });
@Override public Flowable<Integer> apply(Flowable<Integer> f) { return Flowable.concat(f.take(5), f.takeLast(5)); } }).subscribe(ts);
@Test(expected = NullPointerException.class) public void takeLastSizeTimedUnitNull() { just1.takeLast(1, 1, null, Schedulers.single()); }
@Override public Flowable<Integer> apply(Flowable<Integer> f) { return Flowable.concat(f.take(5), f.takeLast(5)); } }).subscribe(ts);
@Override public Flowable<Integer> apply(Flowable<Integer> f) { return Flowable.concat(f.take(5), f.takeLast(5)); } }).subscribe(ts);
@Override public Publisher<Flowable<Object>> apply(Flowable<Object> f) throws Exception { return f.window(Flowable.never()).takeLast(1); } });
@Test public void testTakeLastEmpty() { Flowable<String> w = Flowable.empty(); Flowable<String> take = w.takeLast(2); Subscriber<String> subscriber = TestHelper.mockSubscriber(); take.subscribe(subscriber); verify(subscriber, never()).onNext(any(String.class)); verify(subscriber, never()).onError(any(Throwable.class)); verify(subscriber, times(1)).onComplete(); }
@Override public Flowable<Flowable<Object>> apply(Flowable<Object> f) throws Exception { return f.window(Functions.justCallable(Flowable.never())).takeLast(1); } });
@Test public void testLastWithBackpressure() { MySubscriber<Integer> s = new MySubscriber<Integer>(0); Flowable.just(1).takeLast(1).subscribe(s); assertEquals(0, s.list.size()); s.requestMore(1); assertEquals(1, s.list.size()); }
@Test public void takeLastTimeAndSize() { Flowable.just(1, 2) .takeLast(1, 1, TimeUnit.MINUTES) .test() .assertResult(2); }
@Test public void error() { Flowable.error(new TestException()) .takeLast(5) .test() .assertFailure(TestException.class); }
@Test public void error() { Flowable.error(new TestException()) .takeLast(1) .test() .assertFailure(TestException.class); } }
@Test public void takeLastTake() { Flowable.range(1, 10) .takeLast(5) .take(2) .test() .assertResult(6, 7); } }
@Test public void takeLastTimeDelayErrorCustomScheduler() { Flowable.just(1, 2).concatWith(Flowable.<Integer>error(new TestException())) .takeLast(1, TimeUnit.MINUTES, Schedulers.io(), true) .test() .assertFailure(TestException.class, 1, 2); }
@Test public void takeLastTimeDelayError() { Flowable.just(1, 2).concatWith(Flowable.<Integer>error(new TestException())) .takeLast(1, TimeUnit.MINUTES, true) .test() .assertFailure(TestException.class, 1, 2); }
@Test public void testLastOfManyReturnsLast() { TestSubscriber<Integer> s = new TestSubscriber<Integer>(); Flowable.range(1, 10).takeLast(1).subscribe(s); s.assertValue(10); s.assertNoErrors(); s.assertTerminated(); // NO longer assertable // s.assertUnsubscribed(); }
@Test public void testLastOfEmptyReturnsEmpty() { TestSubscriber<Object> s = new TestSubscriber<Object>(); Flowable.empty().takeLast(1).subscribe(s); s.assertNoValues(); s.assertNoErrors(); s.assertTerminated(); // NO longer assertable // s.assertUnsubscribed(); }
@Test public void fromArray() { String[] items = new String[] { "one", "two", "three" }; assertEquals((Long)3L, Flowable.fromArray(items).count().blockingGet()); assertEquals("two", Flowable.fromArray(items).skip(1).take(1).blockingSingle()); assertEquals("three", Flowable.fromArray(items).takeLast(1).blockingSingle()); }
@Test public void testBackpressure2() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(1, 100000).takeLast(Flowable.bufferSize() * 4) .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(Flowable.bufferSize() * 4, ts.valueCount()); }