Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSkipLastTimedTest.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.any;
17 import static org.mockito.Mockito.*;
18
19 import java.util.concurrent.TimeUnit;
20
21 import org.junit.Test;
22 import org.mockito.InOrder;
23
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.exceptions.TestException;
26 import io.reactivex.rxjava3.functions.Function;
27 import io.reactivex.rxjava3.observers.TestObserver;
28 import io.reactivex.rxjava3.schedulers.*;
29 import io.reactivex.rxjava3.subjects.PublishSubject;
30 import io.reactivex.rxjava3.testsupport.TestHelper;
31
32 public class ObservableSkipLastTimedTest extends RxJavaTest {
33
34 @Test
35 public void skipLastTimed() {
36 TestScheduler scheduler = new TestScheduler();
37
38 PublishSubject<Integer> source = PublishSubject.create();
39
40 // FIXME the timeunit now matters due to rounding
41 Observable<Integer> result = source.skipLast(1000, TimeUnit.MILLISECONDS, scheduler);
42
43 Observer<Object> o = TestHelper.mockObserver();
44
45 result.subscribe(o);
46
47 source.onNext(1);
48 source.onNext(2);
49 source.onNext(3);
50
51 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
52
53 source.onNext(4);
54 source.onNext(5);
55 source.onNext(6);
56
57 scheduler.advanceTimeBy(950, TimeUnit.MILLISECONDS);
58 source.onComplete();
59
60 InOrder inOrder = inOrder(o);
61 inOrder.verify(o).onNext(1);
62 inOrder.verify(o).onNext(2);
63 inOrder.verify(o).onNext(3);
64 inOrder.verify(o, never()).onNext(4);
65 inOrder.verify(o, never()).onNext(5);
66 inOrder.verify(o, never()).onNext(6);
67 inOrder.verify(o).onComplete();
68 inOrder.verifyNoMoreInteractions();
69
70 verify(o, never()).onError(any(Throwable.class));
71 }
72
73 @Test
74 public void skipLastTimedErrorBeforeTime() {
75 TestScheduler scheduler = new TestScheduler();
76
77 PublishSubject<Integer> source = PublishSubject.create();
78
79 Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
80
81 Observer<Object> o = TestHelper.mockObserver();
82
83 result.subscribe(o);
84
85 source.onNext(1);
86 source.onNext(2);
87 source.onNext(3);
88 source.onError(new TestException());
89
90 scheduler.advanceTimeBy(1050, TimeUnit.MILLISECONDS);
91
92 verify(o).onError(any(TestException.class));
93
94 verify(o, never()).onComplete();
95 verify(o, never()).onNext(any());
96 }
97
98 @Test
99 public void skipLastTimedCompleteBeforeTime() {
100 TestScheduler scheduler = new TestScheduler();
101
102 PublishSubject<Integer> source = PublishSubject.create();
103
104 Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
105
106 Observer<Object> o = TestHelper.mockObserver();
107
108 result.subscribe(o);
109
110 source.onNext(1);
111 source.onNext(2);
112 source.onNext(3);
113
114 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
115
116 source.onComplete();
117
118 InOrder inOrder = inOrder(o);
119 inOrder.verify(o).onComplete();
120 inOrder.verifyNoMoreInteractions();
121
122 verify(o, never()).onNext(any());
123 verify(o, never()).onError(any(Throwable.class));
124 }
125
126 @Test
127 public void skipLastTimedWhenAllElementsAreValid() {
128 TestScheduler scheduler = new TestScheduler();
129
130 PublishSubject<Integer> source = PublishSubject.create();
131
132 Observable<Integer> result = source.skipLast(1, TimeUnit.MILLISECONDS, scheduler);
133
134 Observer<Object> o = TestHelper.mockObserver();
135
136 result.subscribe(o);
137
138 source.onNext(1);
139 source.onNext(2);
140 source.onNext(3);
141
142 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
143
144 source.onComplete();
145
146 InOrder inOrder = inOrder(o);
147 inOrder.verify(o).onNext(1);
148 inOrder.verify(o).onNext(2);
149 inOrder.verify(o).onNext(3);
150 inOrder.verify(o).onComplete();
151 inOrder.verifyNoMoreInteractions();
152 }
153
154 @Test
155 public void skipLastTimedDefaultScheduler() {
156 Observable.just(1).concatWith(Observable.just(2).delay(500, TimeUnit.MILLISECONDS))
157 .skipLast(300, TimeUnit.MILLISECONDS)
158 .test()
159 .awaitDone(5, TimeUnit.SECONDS)
160 .assertResult(1);
161 }
162
163 @Test
164 public void skipLastTimedDefaultSchedulerDelayError() {
165 Observable.just(1).concatWith(Observable.just(2).delay(500, TimeUnit.MILLISECONDS))
166 .skipLast(300, TimeUnit.MILLISECONDS, true)
167 .test()
168 .awaitDone(5, TimeUnit.SECONDS)
169 .assertResult(1);
170 }
171
172 @Test
173 public void skipLastTimedCustomSchedulerDelayError() {
174 Observable.just(1).concatWith(Observable.just(2).delay(500, TimeUnit.MILLISECONDS))
175 .skipLast(300, TimeUnit.MILLISECONDS, Schedulers.io(), true)
176 .test()
177 .awaitDone(5, TimeUnit.SECONDS)
178 .assertResult(1);
179 }
180
181 @Test
182 public void dispose() {
183 TestHelper.checkDisposed(PublishSubject.create().skipLast(1, TimeUnit.DAYS));
184 }
185
186 @Test
187 public void doubleOnSubscribe() {
188 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Object>>() {
189 @Override
190 public ObservableSource<Object> apply(Observable<Object> o) throws Exception {
191 return o.skipLast(1, TimeUnit.DAYS);
192 }
193 });
194 }
195
196 @Test
197 public void onCompleteDisposeRace() {
198 TestScheduler scheduler = new TestScheduler();
199 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
200 final PublishSubject<Integer> ps = PublishSubject.create();
201
202 final TestObserver<Integer> to = ps.skipLast(1, TimeUnit.DAYS, scheduler).test();
203
204 Runnable r1 = new Runnable() {
205 @Override
206 public void run() {
207 ps.onComplete();
208 }
209 };
210
211 Runnable r2 = new Runnable() {
212 @Override
213 public void run() {
214 to.dispose();
215 }
216 };
217
218 TestHelper.race(r1, r2);
219 }
220 }
221
222 @Test
223 public void onCompleteDisposeDelayErrorRace() {
224 TestScheduler scheduler = new TestScheduler();
225 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
226 final PublishSubject<Integer> ps = PublishSubject.create();
227
228 final TestObserver<Integer> to = ps.skipLast(1, TimeUnit.DAYS, scheduler, true).test();
229
230 Runnable r1 = new Runnable() {
231 @Override
232 public void run() {
233 ps.onComplete();
234 }
235 };
236
237 Runnable r2 = new Runnable() {
238 @Override
239 public void run() {
240 to.dispose();
241 }
242 };
243
244 TestHelper.race(r1, r2);
245 }
246 }
247
248 @Test
249 public void errorDelayed() {
250 Observable.error(new TestException())
251 .skipLast(1, TimeUnit.DAYS, new TestScheduler(), true)
252 .test()
253 .assertFailure(TestException.class);
254 }
255
256 @Test
257 public void take() {
258 Observable.just(1)
259 .skipLast(0, TimeUnit.SECONDS)
260 .take(1)
261 .test()
262 .awaitDone(5, TimeUnit.SECONDS)
263 .assertResult(1);
264 }
265
266 @Test
267 public void onNextDisposeRace() {
268 TestScheduler scheduler = new TestScheduler();
269 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
270 final PublishSubject<Integer> ps = PublishSubject.create();
271
272 final TestObserver<Integer> to = ps.skipLast(1, TimeUnit.DAYS, scheduler).test();
273
274 Runnable r1 = new Runnable() {
275 @Override
276 public void run() {
277 ps.onNext(1);
278 }
279 };
280
281 Runnable r2 = new Runnable() {
282 @Override
283 public void run() {
284 to.dispose();
285 }
286 };
287
288 TestHelper.race(r1, r2);
289 }
290 }
291
292 @Test
293 public void onNextOnCompleteDisposeDelayErrorRace() {
294 TestScheduler scheduler = new TestScheduler();
295 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
296 final PublishSubject<Integer> ps = PublishSubject.create();
297
298 final TestObserver<Integer> to = ps.skipLast(1, TimeUnit.DAYS, scheduler, true).test();
299
300 Runnable r1 = new Runnable() {
301 @Override
302 public void run() {
303 ps.onNext(1);
304 ps.onComplete();
305 }
306 };
307
308 Runnable r2 = new Runnable() {
309 @Override
310 public void run() {
311 to.dispose();
312 }
313 };
314
315 TestHelper.race(r1, r2);
316 }
317 }
318
319 @Test
320 public void skipLastTimedDelayError() {
321 TestScheduler scheduler = new TestScheduler();
322
323 PublishSubject<Integer> source = PublishSubject.create();
324
325 // FIXME the timeunit now matters due to rounding
326 Observable<Integer> result = source.skipLast(1000, TimeUnit.MILLISECONDS, scheduler, true);
327
328 Observer<Object> o = TestHelper.mockObserver();
329
330 result.subscribe(o);
331
332 source.onNext(1);
333 source.onNext(2);
334 source.onNext(3);
335
336 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
337
338 source.onNext(4);
339 source.onNext(5);
340 source.onNext(6);
341
342 scheduler.advanceTimeBy(950, TimeUnit.MILLISECONDS);
343 source.onComplete();
344
345 InOrder inOrder = inOrder(o);
346 inOrder.verify(o).onNext(1);
347 inOrder.verify(o).onNext(2);
348 inOrder.verify(o).onNext(3);
349 inOrder.verify(o, never()).onNext(4);
350 inOrder.verify(o, never()).onNext(5);
351 inOrder.verify(o, never()).onNext(6);
352 inOrder.verify(o).onComplete();
353 inOrder.verifyNoMoreInteractions();
354
355 verify(o, never()).onError(any(Throwable.class));
356 }
357
358 @Test
359 public void skipLastTimedErrorBeforeTimeDelayError() {
360 TestScheduler scheduler = new TestScheduler();
361
362 PublishSubject<Integer> source = PublishSubject.create();
363
364 Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler, true);
365
366 Observer<Object> o = TestHelper.mockObserver();
367
368 result.subscribe(o);
369
370 source.onNext(1);
371 source.onNext(2);
372 source.onNext(3);
373 source.onError(new TestException());
374
375 scheduler.advanceTimeBy(1050, TimeUnit.MILLISECONDS);
376
377 verify(o).onError(any(TestException.class));
378
379 verify(o, never()).onComplete();
380 verify(o, never()).onNext(any());
381 }
382
383 @Test
384 public void skipLastTimedCompleteBeforeTimeDelayError() {
385 TestScheduler scheduler = new TestScheduler();
386
387 PublishSubject<Integer> source = PublishSubject.create();
388
389 Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler, true);
390
391 Observer<Object> o = TestHelper.mockObserver();
392
393 result.subscribe(o);
394
395 source.onNext(1);
396 source.onNext(2);
397 source.onNext(3);
398
399 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
400
401 source.onComplete();
402
403 InOrder inOrder = inOrder(o);
404 inOrder.verify(o).onComplete();
405 inOrder.verifyNoMoreInteractions();
406
407 verify(o, never()).onNext(any());
408 verify(o, never()).onError(any(Throwable.class));
409 }
410
411 @Test
412 public void skipLastTimedWhenAllElementsAreValidDelayError() {
413 TestScheduler scheduler = new TestScheduler();
414
415 PublishSubject<Integer> source = PublishSubject.create();
416
417 Observable<Integer> result = source.skipLast(1, TimeUnit.MILLISECONDS, scheduler, true);
418
419 Observer<Object> o = TestHelper.mockObserver();
420
421 result.subscribe(o);
422
423 source.onNext(1);
424 source.onNext(2);
425 source.onNext(3);
426
427 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
428
429 source.onComplete();
430
431 InOrder inOrder = inOrder(o);
432 inOrder.verify(o).onNext(1);
433 inOrder.verify(o).onNext(2);
434 inOrder.verify(o).onNext(3);
435 inOrder.verify(o).onComplete();
436 inOrder.verifyNoMoreInteractions();
437 }
438 }