Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableLastTest.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.flowable;
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.NoSuchElementException;
21
22 import org.junit.Test;
23 import org.mockito.InOrder;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.exceptions.TestException;
27 import io.reactivex.rxjava3.functions.*;
28 import io.reactivex.rxjava3.testsupport.TestHelper;
29
30 public class FlowableLastTest extends RxJavaTest {
31
32 @Test
33 public void lastWithElements() {
34 Maybe<Integer> last = Flowable.just(1, 2, 3).lastElement();
35 assertEquals(3, last.blockingGet().intValue());
36 }
37
38 @Test
39 public void lastWithNoElements() {
40 Maybe<?> last = Flowable.empty().lastElement();
41 assertNull(last.blockingGet());
42 }
43
44 @Test
45 public void lastMultiSubscribe() {
46 Maybe<Integer> last = Flowable.just(1, 2, 3).lastElement();
47 assertEquals(3, last.blockingGet().intValue());
48 assertEquals(3, last.blockingGet().intValue());
49 }
50
51 @Test
52 public void lastViaFlowable() {
53 Flowable.just(1, 2, 3).lastElement();
54 }
55
56 @Test
57 public void last() {
58 Maybe<Integer> maybe = Flowable.just(1, 2, 3).lastElement();
59
60 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
61 maybe.subscribe(observer);
62
63 InOrder inOrder = inOrder(observer);
64 inOrder.verify(observer, times(1)).onSuccess(3);
65 // inOrder.verify(observer, times(1)).onComplete();
66 inOrder.verifyNoMoreInteractions();
67 }
68
69 @Test
70 public void lastWithOneElement() {
71 Maybe<Integer> maybe = Flowable.just(1).lastElement();
72
73 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
74 maybe.subscribe(observer);
75
76 InOrder inOrder = inOrder(observer);
77 inOrder.verify(observer, times(1)).onSuccess(1);
78 // inOrder.verify(observer, times(1)).onComplete();
79 inOrder.verifyNoMoreInteractions();
80 }
81
82 @Test
83 public void lastWithEmpty() {
84 Maybe<Integer> maybe = Flowable.<Integer> empty().lastElement();
85
86 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
87 maybe.subscribe(observer);
88
89 InOrder inOrder = inOrder(observer);
90 inOrder.verify(observer).onComplete();
91 inOrder.verify(observer, never()).onError(any(Throwable.class));
92 inOrder.verifyNoMoreInteractions();
93 }
94
95 @Test
96 public void lastWithPredicate() {
97 Maybe<Integer> maybe = Flowable.just(1, 2, 3, 4, 5, 6)
98 .filter(new Predicate<Integer>() {
99
100 @Override
101 public boolean test(Integer t1) {
102 return t1 % 2 == 0;
103 }
104 })
105 .lastElement();
106
107 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
108 maybe.subscribe(observer);
109
110 InOrder inOrder = inOrder(observer);
111 inOrder.verify(observer, times(1)).onSuccess(6);
112 // inOrder.verify(observer, times(1)).onComplete();
113 inOrder.verifyNoMoreInteractions();
114 }
115
116 @Test
117 public void lastWithPredicateAndOneElement() {
118 Maybe<Integer> maybe = Flowable.just(1, 2)
119 .filter(
120 new Predicate<Integer>() {
121
122 @Override
123 public boolean test(Integer t1) {
124 return t1 % 2 == 0;
125 }
126 })
127 .lastElement();
128
129 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
130 maybe.subscribe(observer);
131
132 InOrder inOrder = inOrder(observer);
133 inOrder.verify(observer, times(1)).onSuccess(2);
134 // inOrder.verify(observer, times(1)).onComplete();
135 inOrder.verifyNoMoreInteractions();
136 }
137
138 @Test
139 public void lastWithPredicateAndEmpty() {
140 Maybe<Integer> maybe = Flowable.just(1)
141 .filter(
142 new Predicate<Integer>() {
143
144 @Override
145 public boolean test(Integer t1) {
146 return t1 % 2 == 0;
147 }
148 }).lastElement();
149
150 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
151 maybe.subscribe(observer);
152
153 InOrder inOrder = inOrder(observer);
154 inOrder.verify(observer).onComplete();
155 inOrder.verify(observer, never()).onError(any(Throwable.class));
156 inOrder.verifyNoMoreInteractions();
157 }
158
159 @Test
160 public void lastOrDefault() {
161 Single<Integer> single = Flowable.just(1, 2, 3)
162 .last(4);
163
164 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
165 single.subscribe(observer);
166
167 InOrder inOrder = inOrder(observer);
168 inOrder.verify(observer, times(1)).onSuccess(3);
169 // inOrder.verify(observer, times(1)).onComplete();
170 inOrder.verifyNoMoreInteractions();
171 }
172
173 @Test
174 public void lastOrDefaultWithOneElement() {
175 Single<Integer> single = Flowable.just(1).last(2);
176
177 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
178 single.subscribe(observer);
179
180 InOrder inOrder = inOrder(observer);
181 inOrder.verify(observer, times(1)).onSuccess(1);
182 // inOrder.verify(observer, times(1)).onComplete();
183 inOrder.verifyNoMoreInteractions();
184 }
185
186 @Test
187 public void lastOrDefaultWithEmpty() {
188 Single<Integer> single = Flowable.<Integer> empty()
189 .last(1);
190
191 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
192 single.subscribe(observer);
193
194 InOrder inOrder = inOrder(observer);
195 inOrder.verify(observer, times(1)).onSuccess(1);
196 // inOrder.verify(observer, times(1)).onComplete();
197 inOrder.verifyNoMoreInteractions();
198 }
199
200 @Test
201 public void lastOrDefaultWithPredicate() {
202 Single<Integer> single = Flowable.just(1, 2, 3, 4, 5, 6)
203 .filter(new Predicate<Integer>() {
204
205 @Override
206 public boolean test(Integer t1) {
207 return t1 % 2 == 0;
208 }
209 })
210 .last(8);
211
212 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
213 single.subscribe(observer);
214
215 InOrder inOrder = inOrder(observer);
216 inOrder.verify(observer, times(1)).onSuccess(6);
217 // inOrder.verify(observer, times(1)).onComplete();
218 inOrder.verifyNoMoreInteractions();
219 }
220
221 @Test
222 public void lastOrDefaultWithPredicateAndOneElement() {
223 Single<Integer> single = Flowable.just(1, 2)
224 .filter(new Predicate<Integer>() {
225
226 @Override
227 public boolean test(Integer t1) {
228 return t1 % 2 == 0;
229 }
230 })
231 .last(4);
232
233 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
234 single.subscribe(observer);
235
236 InOrder inOrder = inOrder(observer);
237 inOrder.verify(observer, times(1)).onSuccess(2);
238 // inOrder.verify(observer, times(1)).onComplete();
239 inOrder.verifyNoMoreInteractions();
240 }
241
242 @Test
243 public void lastOrDefaultWithPredicateAndEmpty() {
244 Single<Integer> single = Flowable.just(1)
245 .filter(
246 new Predicate<Integer>() {
247
248 @Override
249 public boolean test(Integer t1) {
250 return t1 % 2 == 0;
251 }
252 })
253 .last(2);
254
255 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
256 single.subscribe(observer);
257
258 InOrder inOrder = inOrder(observer);
259 inOrder.verify(observer, times(1)).onSuccess(2);
260 // inOrder.verify(observer, times(1)).onComplete();
261 inOrder.verifyNoMoreInteractions();
262 }
263
264 @Test
265 public void lastOrErrorNoElement() {
266 Flowable.empty()
267 .lastOrError()
268 .test()
269 .assertNoValues()
270 .assertError(NoSuchElementException.class);
271 }
272
273 @Test
274 public void lastOrErrorOneElement() {
275 Flowable.just(1)
276 .lastOrError()
277 .test()
278 .assertNoErrors()
279 .assertValue(1);
280 }
281
282 @Test
283 public void lastOrErrorMultipleElements() {
284 Flowable.just(1, 2, 3)
285 .lastOrError()
286 .test()
287 .assertNoErrors()
288 .assertValue(3);
289 }
290
291 @Test
292 public void lastOrErrorError() {
293 Flowable.error(new RuntimeException("error"))
294 .lastOrError()
295 .to(TestHelper.testConsumer())
296 .assertNoValues()
297 .assertErrorMessage("error")
298 .assertError(RuntimeException.class);
299 }
300
301 @Test
302 public void dispose() {
303 TestHelper.checkDisposed(Flowable.never().lastElement().toFlowable());
304 TestHelper.checkDisposed(Flowable.never().lastElement());
305
306 TestHelper.checkDisposed(Flowable.just(1).lastOrError().toFlowable());
307 TestHelper.checkDisposed(Flowable.just(1).lastOrError());
308
309 TestHelper.checkDisposed(Flowable.just(1).last(2).toFlowable());
310 TestHelper.checkDisposed(Flowable.just(1).last(2));
311 }
312
313 @Test
314 public void doubleOnSubscribe() {
315 TestHelper.checkDoubleOnSubscribeFlowableToMaybe(new Function<Flowable<Object>, MaybeSource<Object>>() {
316 @Override
317 public MaybeSource<Object> apply(Flowable<Object> f) throws Exception {
318 return f.lastElement();
319 }
320 });
321 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Flowable<Object>>() {
322 @Override
323 public Flowable<Object> apply(Flowable<Object> f) throws Exception {
324 return f.lastElement().toFlowable();
325 }
326 });
327
328 TestHelper.checkDoubleOnSubscribeFlowableToSingle(new Function<Flowable<Object>, SingleSource<Object>>() {
329 @Override
330 public SingleSource<Object> apply(Flowable<Object> f) throws Exception {
331 return f.lastOrError();
332 }
333 });
334 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Flowable<Object>>() {
335 @Override
336 public Flowable<Object> apply(Flowable<Object> f) throws Exception {
337 return f.lastOrError().toFlowable();
338 }
339 });
340
341 TestHelper.checkDoubleOnSubscribeFlowableToSingle(new Function<Flowable<Object>, SingleSource<Object>>() {
342 @Override
343 public SingleSource<Object> apply(Flowable<Object> f) throws Exception {
344 return f.last(2);
345 }
346 });
347 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Flowable<Object>>() {
348 @Override
349 public Flowable<Object> apply(Flowable<Object> f) throws Exception {
350 return f.last(2).toFlowable();
351 }
352 });
353 }
354
355 @Test
356 public void error() {
357 Flowable.error(new TestException())
358 .lastElement()
359 .test()
360 .assertFailure(TestException.class);
361 }
362
363 @Test
364 public void errorLastOrErrorFlowable() {
365 Flowable.error(new TestException())
366 .lastOrError()
367 .toFlowable()
368 .test()
369 .assertFailure(TestException.class);
370 }
371
372 @Test
373 public void emptyLastOrErrorFlowable() {
374 Flowable.empty()
375 .lastOrError()
376 .toFlowable()
377 .test()
378 .assertFailure(NoSuchElementException.class);
379 }
380 }