Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTest.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.observable;
15
16 import static org.junit.Assert.*;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.concurrent.TimeUnit;
21 import java.util.concurrent.atomic.AtomicInteger;
22
23 import org.junit.Test;
24 import org.mockito.InOrder;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.functions.*;
29 import io.reactivex.rxjava3.observers.*;
30 import io.reactivex.rxjava3.schedulers.Schedulers;
31 import io.reactivex.rxjava3.testsupport.TestHelper;
32
33 public class ObservableTakeLastTest extends RxJavaTest {
34
35 @Test
36 public void takeLastEmpty() {
37 Observable<String> w = Observable.empty();
38 Observable<String> take = w.takeLast(2);
39
40 Observer<String> observer = TestHelper.mockObserver();
41 take.subscribe(observer);
42 verify(observer, never()).onNext(any(String.class));
43 verify(observer, never()).onError(any(Throwable.class));
44 verify(observer, times(1)).onComplete();
45 }
46
47 @Test
48 public void takeLast1() {
49 Observable<String> w = Observable.just("one", "two", "three");
50 Observable<String> take = w.takeLast(2);
51
52 Observer<String> observer = TestHelper.mockObserver();
53 InOrder inOrder = inOrder(observer);
54 take.subscribe(observer);
55 inOrder.verify(observer, times(1)).onNext("two");
56 inOrder.verify(observer, times(1)).onNext("three");
57 verify(observer, never()).onNext("one");
58 verify(observer, never()).onError(any(Throwable.class));
59 verify(observer, times(1)).onComplete();
60 }
61
62 @Test
63 public void takeLast2() {
64 Observable<String> w = Observable.just("one");
65 Observable<String> take = w.takeLast(10);
66
67 Observer<String> observer = TestHelper.mockObserver();
68 take.subscribe(observer);
69 verify(observer, times(1)).onNext("one");
70 verify(observer, never()).onError(any(Throwable.class));
71 verify(observer, times(1)).onComplete();
72 }
73
74 @Test
75 public void takeLastWithZeroCount() {
76 Observable<String> w = Observable.just("one");
77 Observable<String> take = w.takeLast(0);
78
79 Observer<String> observer = TestHelper.mockObserver();
80 take.subscribe(observer);
81 verify(observer, never()).onNext("one");
82 verify(observer, never()).onError(any(Throwable.class));
83 verify(observer, times(1)).onComplete();
84 }
85
86 @Test(expected = IllegalArgumentException.class)
87 public void takeLastWithNegativeCount() {
88 Observable.just("one").takeLast(-1);
89 }
90
91 @Test
92 public void backpressure1() {
93 TestObserver<Integer> to = new TestObserver<>();
94 Observable.range(1, 100000).takeLast(1)
95 .observeOn(Schedulers.newThread())
96 .map(newSlowProcessor()).subscribe(to);
97 to.awaitDone(5, TimeUnit.SECONDS);
98 to.assertNoErrors();
99 to.assertValue(100000);
100 }
101
102 @Test
103 public void backpressure2() {
104 TestObserver<Integer> to = new TestObserver<>();
105 Observable.range(1, 100000).takeLast(Flowable.bufferSize() * 4)
106 .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(to);
107 to.awaitDone(5, TimeUnit.SECONDS);
108 to.assertNoErrors();
109 assertEquals(Flowable.bufferSize() * 4, to.values().size());
110 }
111
112 private Function<Integer, Integer> newSlowProcessor() {
113 return new Function<Integer, Integer>() {
114 int c;
115
116 @Override
117 public Integer apply(Integer i) {
118 if (c++ < 100) {
119 try {
120 Thread.sleep(1);
121 } catch (InterruptedException e) {
122 }
123 }
124 return i;
125 }
126
127 };
128 }
129
130 @Test
131 public void issue1522() {
132 // https://github.com/ReactiveX/RxJava/issues/1522
133 assertNull(Observable
134 .empty()
135 .count()
136 .filter(new Predicate<Long>() {
137 @Override
138 public boolean test(Long v) {
139 return false;
140 }
141 })
142 .blockingGet());
143 }
144
145 @Test
146 public void unsubscribeTakesEffectEarlyOnFastPath() {
147 final AtomicInteger count = new AtomicInteger();
148 Observable.range(0, 100000).takeLast(100000).subscribe(new DefaultObserver<Integer>() {
149
150 @Override
151 public void onStart() {
152 }
153
154 @Override
155 public void onComplete() {
156
157 }
158
159 @Override
160 public void onError(Throwable e) {
161 }
162
163 @Override
164 public void onNext(Integer integer) {
165 count.incrementAndGet();
166 cancel();
167 }
168 });
169 assertEquals(1, count.get());
170 }
171
172 @Test
173 public void dispose() {
174 TestHelper.checkDisposed(Observable.range(1, 10).takeLast(5));
175 }
176
177 @Test
178 public void doubleOnSubscribe() {
179 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Object>>() {
180 @Override
181 public ObservableSource<Object> apply(Observable<Object> o) throws Exception {
182 return o.takeLast(5);
183 }
184 });
185 }
186
187 @Test
188 public void error() {
189 Observable.error(new TestException())
190 .takeLast(5)
191 .test()
192 .assertFailure(TestException.class);
193 }
194
195 @Test
196 public void takeLastTake() {
197 Observable.range(1, 10)
198 .takeLast(5)
199 .take(2)
200 .test()
201 .assertResult(6, 7);
202 }
203 }