Debian Codegraph @

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