Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeWhileTest.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.fail;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.core.*;
23 import io.reactivex.rxjava3.disposables.*;
24 import io.reactivex.rxjava3.exceptions.TestException;
25 import io.reactivex.rxjava3.functions.*;
26 import io.reactivex.rxjava3.internal.functions.Functions;
27 import io.reactivex.rxjava3.observers.TestObserver;
28 import io.reactivex.rxjava3.subjects.*;
29 import io.reactivex.rxjava3.testsupport.*;
30
31 public class ObservableTakeWhileTest extends RxJavaTest {
32
33 @Test
34 public void takeWhile1() {
35 Observable<Integer> w = Observable.just(1, 2, 3);
36 Observable<Integer> take = w.takeWhile(new Predicate<Integer>() {
37 @Override
38 public boolean test(Integer input) {
39 return input < 3;
40 }
41 });
42
43 Observer<Integer> observer = TestHelper.mockObserver();
44 take.subscribe(observer);
45 verify(observer, times(1)).onNext(1);
46 verify(observer, times(1)).onNext(2);
47 verify(observer, never()).onNext(3);
48 verify(observer, never()).onError(any(Throwable.class));
49 verify(observer, times(1)).onComplete();
50 }
51
52 @Test
53 public void takeWhileOnSubject1() {
54 Subject<Integer> s = PublishSubject.create();
55 Observable<Integer> take = s.takeWhile(new Predicate<Integer>() {
56 @Override
57 public boolean test(Integer input) {
58 return input < 3;
59 }
60 });
61
62 Observer<Integer> observer = TestHelper.mockObserver();
63 take.subscribe(observer);
64
65 s.onNext(1);
66 s.onNext(2);
67 s.onNext(3);
68 s.onNext(4);
69 s.onNext(5);
70 s.onComplete();
71
72 verify(observer, times(1)).onNext(1);
73 verify(observer, times(1)).onNext(2);
74 verify(observer, never()).onNext(3);
75 verify(observer, never()).onNext(4);
76 verify(observer, never()).onNext(5);
77 verify(observer, never()).onError(any(Throwable.class));
78 verify(observer, times(1)).onComplete();
79 }
80
81 @Test
82 public void takeWhile2() {
83 Observable<String> w = Observable.just("one", "two", "three");
84 Observable<String> take = w.takeWhile(new Predicate<String>() {
85 int index;
86
87 @Override
88 public boolean test(String input) {
89 return index++ < 2;
90 }
91 });
92
93 Observer<String> observer = TestHelper.mockObserver();
94 take.subscribe(observer);
95 verify(observer, times(1)).onNext("one");
96 verify(observer, times(1)).onNext("two");
97 verify(observer, never()).onNext("three");
98 verify(observer, never()).onError(any(Throwable.class));
99 verify(observer, times(1)).onComplete();
100 }
101
102 @Test
103 @SuppressUndeliverable
104 public void takeWhileDoesntLeakErrors() {
105 Observable<String> source = Observable.unsafeCreate(new ObservableSource<String>() {
106 @Override
107 public void subscribe(Observer<? super String> observer) {
108 observer.onSubscribe(Disposable.empty());
109 observer.onNext("one");
110 observer.onError(new Throwable("test failed"));
111 }
112 });
113
114 source.takeWhile(new Predicate<String>() {
115 @Override
116 public boolean test(String s) {
117 return false;
118 }
119 }).blockingLast("");
120 }
121
122 @Test
123 public void takeWhileProtectsPredicateCall() {
124 TestObservable source = new TestObservable(mock(Disposable.class), "one");
125 final RuntimeException testException = new RuntimeException("test exception");
126
127 Observer<String> observer = TestHelper.mockObserver();
128 Observable<String> take = Observable.unsafeCreate(source)
129 .takeWhile(new Predicate<String>() {
130 @Override
131 public boolean test(String s) {
132 throw testException;
133 }
134 });
135 take.subscribe(observer);
136
137 // wait for the Observable to complete
138 try {
139 source.t.join();
140 } catch (Throwable e) {
141 e.printStackTrace();
142 fail(e.getMessage());
143 }
144
145 verify(observer, never()).onNext(any(String.class));
146 verify(observer, times(1)).onError(testException);
147 }
148
149 @Test
150 public void unsubscribeAfterTake() {
151 Disposable upstream = mock(Disposable.class);
152 TestObservable w = new TestObservable(upstream, "one", "two", "three");
153
154 Observer<String> observer = TestHelper.mockObserver();
155 Observable<String> take = Observable.unsafeCreate(w)
156 .takeWhile(new Predicate<String>() {
157 int index;
158
159 @Override
160 public boolean test(String s) {
161 return index++ < 1;
162 }
163 });
164 take.subscribe(observer);
165
166 // wait for the Observable to complete
167 try {
168 w.t.join();
169 } catch (Throwable e) {
170 e.printStackTrace();
171 fail(e.getMessage());
172 }
173
174 System.out.println("TestObservable thread finished");
175 verify(observer, times(1)).onNext("one");
176 verify(observer, never()).onNext("two");
177 verify(observer, never()).onNext("three");
178 verify(upstream, times(1)).dispose();
179 }
180
181 private static class TestObservable implements ObservableSource<String> {
182
183 final Disposable upstream;
184 final String[] values;
185 Thread t;
186
187 TestObservable(Disposable upstream, String... values) {
188 this.upstream = upstream;
189 this.values = values;
190 }
191
192 @Override
193 public void subscribe(final Observer<? super String> observer) {
194 System.out.println("TestObservable subscribed to ...");
195 observer.onSubscribe(upstream);
196 t = new Thread(new Runnable() {
197
198 @Override
199 public void run() {
200 try {
201 System.out.println("running TestObservable thread");
202 for (String s : values) {
203 System.out.println("TestObservable onNext: " + s);
204 observer.onNext(s);
205 }
206 observer.onComplete();
207 } catch (Throwable e) {
208 throw new RuntimeException(e);
209 }
210 }
211
212 });
213 System.out.println("starting TestObservable thread");
214 t.start();
215 System.out.println("done starting TestObservable thread");
216 }
217 }
218
219 @Test
220 public void noUnsubscribeDownstream() {
221 Observable<Integer> source = Observable.range(1, 1000).takeWhile(new Predicate<Integer>() {
222 @Override
223 public boolean test(Integer t1) {
224 return t1 < 2;
225 }
226 });
227 TestObserver<Integer> to = new TestObserver<>();
228
229 source.subscribe(to);
230
231 to.assertNoErrors();
232 to.assertValue(1);
233
234 // 2.0.2 - not anymore
235 // Assert.assertTrue("Not cancelled!", ts.isCancelled());
236 }
237
238 @Test
239 public void errorCauseIncludesLastValue() {
240 TestObserverEx<String> to = new TestObserverEx<>();
241 Observable.just("abc").takeWhile(new Predicate<String>() {
242 @Override
243 public boolean test(String t1) {
244 throw new TestException();
245 }
246 }).subscribe(to);
247
248 to.assertTerminated();
249 to.assertNoValues();
250 to.assertError(TestException.class);
251 // FIXME last cause value not recorded
252 // assertTrue(ts.getOnErrorEvents().get(0).getCause().getMessage().contains("abc"));
253 }
254
255 @Test
256 public void dispose() {
257 TestHelper.checkDisposed(PublishSubject.create().takeWhile(Functions.alwaysTrue()));
258 }
259
260 @Test
261 public void doubleOnSubscribe() {
262 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Object>>() {
263 @Override
264 public ObservableSource<Object> apply(Observable<Object> o) throws Exception {
265 return o.takeWhile(Functions.alwaysTrue());
266 }
267 });
268 }
269
270 @Test
271 public void badSource() {
272 new Observable<Integer>() {
273 @Override
274 protected void subscribeActual(Observer<? super Integer> observer) {
275 observer.onSubscribe(Disposable.empty());
276 observer.onComplete();
277 observer.onComplete();
278 }
279 }
280 .takeWhile(Functions.alwaysTrue())
281 .test()
282 .assertResult();
283 }
284 }