Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSequenceEqualTest.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.mockito.ArgumentMatchers.isA;
17 import static org.mockito.Mockito.*;
18
19 import org.junit.Test;
20 import org.mockito.InOrder;
21
22 import io.reactivex.rxjava3.core.*;
23 import io.reactivex.rxjava3.exceptions.TestException;
24 import io.reactivex.rxjava3.functions.BiPredicate;
25 import io.reactivex.rxjava3.observers.TestObserver;
26 import io.reactivex.rxjava3.subjects.PublishSubject;
27 import io.reactivex.rxjava3.testsupport.TestHelper;
28
29 public class ObservableSequenceEqualTest extends RxJavaTest {
30
31 @Test
32 public void observable1() {
33 Observable<Boolean> o = Observable.sequenceEqual(
34 Observable.just("one", "two", "three"),
35 Observable.just("one", "two", "three")).toObservable();
36 verifyResult(o, true);
37 }
38
39 @Test
40 public void observable2() {
41 Observable<Boolean> o = Observable.sequenceEqual(
42 Observable.just("one", "two", "three"),
43 Observable.just("one", "two", "three", "four")).toObservable();
44 verifyResult(o, false);
45 }
46
47 @Test
48 public void observable3() {
49 Observable<Boolean> o = Observable.sequenceEqual(
50 Observable.just("one", "two", "three", "four"),
51 Observable.just("one", "two", "three")).toObservable();
52 verifyResult(o, false);
53 }
54
55 @Test
56 public void withError1Observable() {
57 Observable<Boolean> o = Observable.sequenceEqual(
58 Observable.concat(Observable.just("one"),
59 Observable.<String> error(new TestException())),
60 Observable.just("one", "two", "three")).toObservable();
61 verifyError(o);
62 }
63
64 @Test
65 public void withError2Observable() {
66 Observable<Boolean> o = Observable.sequenceEqual(
67 Observable.just("one", "two", "three"),
68 Observable.concat(Observable.just("one"),
69 Observable.<String> error(new TestException()))).toObservable();
70 verifyError(o);
71 }
72
73 @Test
74 public void withError3Observable() {
75 Observable<Boolean> o = Observable.sequenceEqual(
76 Observable.concat(Observable.just("one"),
77 Observable.<String> error(new TestException())),
78 Observable.concat(Observable.just("one"),
79 Observable.<String> error(new TestException()))).toObservable();
80 verifyError(o);
81 }
82
83 @Test
84 public void withEmpty1Observable() {
85 Observable<Boolean> o = Observable.sequenceEqual(
86 Observable.<String> empty(),
87 Observable.just("one", "two", "three")).toObservable();
88 verifyResult(o, false);
89 }
90
91 @Test
92 public void withEmpty2Observable() {
93 Observable<Boolean> o = Observable.sequenceEqual(
94 Observable.just("one", "two", "three"),
95 Observable.<String> empty()).toObservable();
96 verifyResult(o, false);
97 }
98
99 @Test
100 public void withEmpty3Observable() {
101 Observable<Boolean> o = Observable.sequenceEqual(
102 Observable.<String> empty(), Observable.<String> empty()).toObservable();
103 verifyResult(o, true);
104 }
105
106 @Test
107 public void withEqualityErrorObservable() {
108 Observable<Boolean> o = Observable.sequenceEqual(
109 Observable.just("one"), Observable.just("one"),
110 new BiPredicate<String, String>() {
111 @Override
112 public boolean test(String t1, String t2) {
113 throw new TestException();
114 }
115 }).toObservable();
116 verifyError(o);
117 }
118
119 private void verifyResult(Single<Boolean> o, boolean result) {
120 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
121
122 o.subscribe(observer);
123
124 InOrder inOrder = inOrder(observer);
125 inOrder.verify(observer, times(1)).onSuccess(result);
126 inOrder.verifyNoMoreInteractions();
127 }
128
129 private void verifyError(Observable<Boolean> observable) {
130 Observer<Boolean> observer = TestHelper.mockObserver();
131 observable.subscribe(observer);
132
133 InOrder inOrder = inOrder(observer);
134 inOrder.verify(observer, times(1)).onError(isA(TestException.class));
135 inOrder.verifyNoMoreInteractions();
136 }
137
138 private void verifyError(Single<Boolean> single) {
139 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
140 single.subscribe(observer);
141
142 InOrder inOrder = inOrder(observer);
143 inOrder.verify(observer, times(1)).onError(isA(TestException.class));
144 inOrder.verifyNoMoreInteractions();
145 }
146
147 @Test
148 public void prefetchObservable() {
149 Observable.sequenceEqual(Observable.range(1, 20), Observable.range(1, 20), 2)
150 .toObservable()
151 .test()
152 .assertResult(true);
153 }
154
155 @Test
156 public void disposedObservable() {
157 TestHelper.checkDisposed(Observable.sequenceEqual(Observable.just(1), Observable.just(2)).toObservable());
158 }
159
160 @Test
161 public void one() {
162 Single<Boolean> o = Observable.sequenceEqual(
163 Observable.just("one", "two", "three"),
164 Observable.just("one", "two", "three"));
165 verifyResult(o, true);
166 }
167
168 @Test
169 public void two() {
170 Single<Boolean> o = Observable.sequenceEqual(
171 Observable.just("one", "two", "three"),
172 Observable.just("one", "two", "three", "four"));
173 verifyResult(o, false);
174 }
175
176 @Test
177 public void three() {
178 Single<Boolean> o = Observable.sequenceEqual(
179 Observable.just("one", "two", "three", "four"),
180 Observable.just("one", "two", "three"));
181 verifyResult(o, false);
182 }
183
184 @Test
185 public void withError1() {
186 Single<Boolean> o = Observable.sequenceEqual(
187 Observable.concat(Observable.just("one"),
188 Observable.<String> error(new TestException())),
189 Observable.just("one", "two", "three"));
190 verifyError(o);
191 }
192
193 @Test
194 public void withError2() {
195 Single<Boolean> o = Observable.sequenceEqual(
196 Observable.just("one", "two", "three"),
197 Observable.concat(Observable.just("one"),
198 Observable.<String> error(new TestException())));
199 verifyError(o);
200 }
201
202 @Test
203 public void withError3() {
204 Single<Boolean> o = Observable.sequenceEqual(
205 Observable.concat(Observable.just("one"),
206 Observable.<String> error(new TestException())),
207 Observable.concat(Observable.just("one"),
208 Observable.<String> error(new TestException())));
209 verifyError(o);
210 }
211
212 @Test
213 public void withEmpty1() {
214 Single<Boolean> o = Observable.sequenceEqual(
215 Observable.<String> empty(),
216 Observable.just("one", "two", "three"));
217 verifyResult(o, false);
218 }
219
220 @Test
221 public void withEmpty2() {
222 Single<Boolean> o = Observable.sequenceEqual(
223 Observable.just("one", "two", "three"),
224 Observable.<String> empty());
225 verifyResult(o, false);
226 }
227
228 @Test
229 public void withEmpty3() {
230 Single<Boolean> o = Observable.sequenceEqual(
231 Observable.<String> empty(), Observable.<String> empty());
232 verifyResult(o, true);
233 }
234
235 @Test
236 public void withEqualityError() {
237 Single<Boolean> o = Observable.sequenceEqual(
238 Observable.just("one"), Observable.just("one"),
239 new BiPredicate<String, String>() {
240 @Override
241 public boolean test(String t1, String t2) {
242 throw new TestException();
243 }
244 });
245 verifyError(o);
246 }
247
248 private void verifyResult(Observable<Boolean> o, boolean result) {
249 Observer<Boolean> observer = TestHelper.mockObserver();
250
251 o.subscribe(observer);
252
253 InOrder inOrder = inOrder(observer);
254 inOrder.verify(observer, times(1)).onNext(result);
255 inOrder.verify(observer).onComplete();
256 inOrder.verifyNoMoreInteractions();
257 }
258
259 @Test
260 public void prefetch() {
261 Observable.sequenceEqual(Observable.range(1, 20), Observable.range(1, 20), 2)
262 .test()
263 .assertResult(true);
264 }
265
266 @Test
267 public void disposed() {
268 TestHelper.checkDisposed(Observable.sequenceEqual(Observable.just(1), Observable.just(2)));
269 }
270
271 @Test
272 public void simpleInequal() {
273 Observable.sequenceEqual(Observable.just(1), Observable.just(2))
274 .test()
275 .assertResult(false);
276 }
277
278 @Test
279 public void simpleInequalObservable() {
280 Observable.sequenceEqual(Observable.just(1), Observable.just(2))
281 .toObservable()
282 .test()
283 .assertResult(false);
284 }
285
286 @Test
287 public void onNextCancelRace() {
288 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
289 final PublishSubject<Integer> ps = PublishSubject.create();
290
291 final TestObserver<Boolean> to = Observable.sequenceEqual(Observable.never(), ps).test();
292
293 Runnable r1 = new Runnable() {
294 @Override
295 public void run() {
296 to.dispose();
297 }
298 };
299
300 Runnable r2 = new Runnable() {
301 @Override
302 public void run() {
303 ps.onNext(1);
304 }
305 };
306
307 TestHelper.race(r1, r2);
308
309 to.assertEmpty();
310 }
311 }
312
313 @Test
314 public void onNextCancelRaceObservable() {
315 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
316 final PublishSubject<Integer> ps = PublishSubject.create();
317
318 final TestObserver<Boolean> to = Observable.sequenceEqual(Observable.never(), ps).toObservable().test();
319
320 Runnable r1 = new Runnable() {
321 @Override
322 public void run() {
323 to.dispose();
324 }
325 };
326
327 Runnable r2 = new Runnable() {
328 @Override
329 public void run() {
330 ps.onNext(1);
331 }
332 };
333
334 TestHelper.race(r1, r2);
335
336 to.assertEmpty();
337 }
338 }
339
340 @Test
341 public void firstCompletesBeforeSecond() {
342 Observable.sequenceEqual(Observable.just(1), Observable.empty())
343 .test()
344 .assertResult(false);
345 }
346
347 @Test
348 public void secondCompletesBeforeFirst() {
349 Observable.sequenceEqual(Observable.empty(), Observable.just(1))
350 .test()
351 .assertResult(false);
352 }
353
354 @Test
355 public void bothEmpty() {
356 Observable.sequenceEqual(Observable.empty(), Observable.empty())
357 .test()
358 .assertResult(true);
359 }
360
361 @Test
362 public void bothJust() {
363 Observable.sequenceEqual(Observable.just(1), Observable.just(1))
364 .test()
365 .assertResult(true);
366 }
367
368 @Test
369 public void bothCompleteWhileComparing() {
370 PublishSubject<Integer> ps1 = PublishSubject.create();
371 PublishSubject<Integer> ps2 = PublishSubject.create();
372
373 TestObserver<Boolean> to = Observable.sequenceEqual(ps1, ps2, (a, b) -> {
374 ps1.onNext(1);
375 ps1.onComplete();
376
377 ps2.onNext(1);
378 ps2.onComplete();
379 return a.equals(b);
380 })
381 .test()
382 ;
383
384 ps1.onNext(0);
385 ps2.onNext(0);
386
387 to.assertResult(true);
388 }
389
390 @Test
391 public void bothCompleteWhileComparingAsObservable() {
392 PublishSubject<Integer> ps1 = PublishSubject.create();
393 PublishSubject<Integer> ps2 = PublishSubject.create();
394
395 TestObserver<Boolean> to = Observable.sequenceEqual(ps1, ps2, (a, b) -> {
396 ps1.onNext(1);
397 ps1.onComplete();
398
399 ps2.onNext(1);
400 ps2.onComplete();
401 return a.equals(b);
402 })
403 .toObservable()
404 .test()
405 ;
406
407 ps1.onNext(0);
408 ps2.onNext(0);
409
410 to.assertResult(true);
411 }
412 }