Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableRepeatTest.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.*;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.*;
21 import java.util.concurrent.TimeUnit;
22 import java.util.concurrent.atomic.AtomicInteger;
23
24 import org.junit.Test;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.core.Observable;
28 import io.reactivex.rxjava3.core.Observer;
29 import io.reactivex.rxjava3.disposables.*;
30 import io.reactivex.rxjava3.exceptions.TestException;
31 import io.reactivex.rxjava3.functions.*;
32 import io.reactivex.rxjava3.observers.TestObserver;
33 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
34 import io.reactivex.rxjava3.schedulers.Schedulers;
35 import io.reactivex.rxjava3.subjects.PublishSubject;
36 import io.reactivex.rxjava3.testsupport.*;
37
38 public class ObservableRepeatTest extends RxJavaTest {
39
40 @Test
41 public void repetition() {
42 int num = 10;
43 final AtomicInteger count = new AtomicInteger();
44 int value = Observable.unsafeCreate(new ObservableSource<Integer>() {
45
46 @Override
47 public void subscribe(final Observer<? super Integer> o) {
48 o.onNext(count.incrementAndGet());
49 o.onComplete();
50 }
51 }).repeat().subscribeOn(Schedulers.computation())
52 .take(num).blockingLast();
53
54 assertEquals(num, value);
55 }
56
57 @Test
58 public void repeatTake() {
59 Observable<Integer> xs = Observable.just(1, 2);
60 Object[] ys = xs.repeat().subscribeOn(Schedulers.newThread()).take(4).toList().blockingGet().toArray();
61 assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys);
62 }
63
64 @Test
65 public void noStackOverFlow() {
66 Observable.just(1).repeat().subscribeOn(Schedulers.newThread()).take(100000).blockingLast();
67 }
68
69 @Test
70 public void repeatTakeWithSubscribeOn() throws InterruptedException {
71
72 final AtomicInteger counter = new AtomicInteger();
73 Observable<Integer> oi = Observable.unsafeCreate(new ObservableSource<Integer>() {
74
75 @Override
76 public void subscribe(Observer<? super Integer> sub) {
77 sub.onSubscribe(Disposable.empty());
78 counter.incrementAndGet();
79 sub.onNext(1);
80 sub.onNext(2);
81 sub.onComplete();
82 }
83 }).subscribeOn(Schedulers.newThread());
84
85 Object[] ys = oi.repeat().subscribeOn(Schedulers.newThread()).map(new Function<Integer, Integer>() {
86
87 @Override
88 public Integer apply(Integer t1) {
89 try {
90 Thread.sleep(50);
91 } catch (InterruptedException e) {
92 e.printStackTrace();
93 }
94 return t1;
95 }
96
97 }).take(4).toList().blockingGet().toArray();
98
99 assertEquals(2, counter.get());
100 assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys);
101 }
102
103 @Test
104 public void repeatAndTake() {
105 Observer<Object> o = TestHelper.mockObserver();
106
107 Observable.just(1).repeat().take(10).subscribe(o);
108
109 verify(o, times(10)).onNext(1);
110 verify(o).onComplete();
111 verify(o, never()).onError(any(Throwable.class));
112 }
113
114 @Test
115 public void repeatLimited() {
116 Observer<Object> o = TestHelper.mockObserver();
117
118 Observable.just(1).repeat(10).subscribe(o);
119
120 verify(o, times(10)).onNext(1);
121 verify(o).onComplete();
122 verify(o, never()).onError(any(Throwable.class));
123 }
124
125 @Test
126 public void repeatError() {
127 Observer<Object> o = TestHelper.mockObserver();
128
129 Observable.error(new TestException()).repeat(10).subscribe(o);
130
131 verify(o).onError(any(TestException.class));
132 verify(o, never()).onNext(any());
133 verify(o, never()).onComplete();
134
135 }
136
137 @Test
138 public void repeatZero() {
139 Observer<Object> o = TestHelper.mockObserver();
140
141 Observable.just(1).repeat(0).subscribe(o);
142
143 verify(o).onComplete();
144 verify(o, never()).onNext(any());
145 verify(o, never()).onError(any(Throwable.class));
146 }
147
148 @Test
149 public void repeatOne() {
150 Observer<Object> o = TestHelper.mockObserver();
151
152 Observable.just(1).repeat(1).subscribe(o);
153
154 verify(o).onComplete();
155 verify(o, times(1)).onNext(any());
156 verify(o, never()).onError(any(Throwable.class));
157 }
158
159 /** Issue #2587. */
160 @Test
161 public void repeatAndDistinctUnbounded() {
162 Observable<Integer> src = Observable.fromIterable(Arrays.asList(1, 2, 3, 4, 5))
163 .take(3)
164 .repeat(3)
165 .distinct();
166
167 TestObserverEx<Integer> to = new TestObserverEx<>();
168
169 src.subscribe(to);
170
171 to.assertNoErrors();
172 to.assertTerminated();
173 to.assertValues(1, 2, 3);
174 }
175
176 /** Issue #2844: wrong target of request. */
177 @Test
178 public void repeatRetarget() {
179 final List<Integer> concatBase = new ArrayList<>();
180 TestObserver<Integer> to = new TestObserver<>();
181 Observable.just(1, 2)
182 .repeat(5)
183 .concatMap(new Function<Integer, Observable<Integer>>() {
184 @Override
185 public Observable<Integer> apply(Integer x) {
186 System.out.println("testRepeatRetarget -> " + x);
187 concatBase.add(x);
188 return Observable.<Integer>empty()
189 .delay(200, TimeUnit.MILLISECONDS);
190 }
191 })
192 .subscribe(to);
193
194 to.awaitDone(5, TimeUnit.SECONDS);
195 to.assertNoErrors();
196 to.assertNoValues();
197
198 assertEquals(Arrays.asList(1, 2, 1, 2, 1, 2, 1, 2, 1, 2), concatBase);
199 }
200
201 @Test
202 public void repeatUntil() {
203 Observable.just(1)
204 .repeatUntil(new BooleanSupplier() {
205 @Override
206 public boolean getAsBoolean() throws Exception {
207 return false;
208 }
209 })
210 .take(5)
211 .test()
212 .assertResult(1, 1, 1, 1, 1);
213 }
214
215 @Test
216 public void repeatLongPredicateInvalid() {
217 try {
218 Observable.just(1).repeat(-99);
219 fail("Should have thrown");
220 } catch (IllegalArgumentException ex) {
221 assertEquals("times >= 0 required but it was -99", ex.getMessage());
222 }
223 }
224
225 @Test
226 public void repeatUntilError() {
227 Observable.error(new TestException())
228 .repeatUntil(new BooleanSupplier() {
229 @Override
230 public boolean getAsBoolean() throws Exception {
231 return true;
232 }
233 })
234 .test()
235 .assertFailure(TestException.class);
236 }
237
238 @Test
239 public void repeatUntilFalse() {
240 Observable.just(1)
241 .repeatUntil(new BooleanSupplier() {
242 @Override
243 public boolean getAsBoolean() throws Exception {
244 return true;
245 }
246 })
247 .test()
248 .assertResult(1);
249 }
250
251 @Test
252 public void repeatUntilSupplierCrash() {
253 Observable.just(1)
254 .repeatUntil(new BooleanSupplier() {
255 @Override
256 public boolean getAsBoolean() throws Exception {
257 throw new TestException();
258 }
259 })
260 .test()
261 .assertFailure(TestException.class, 1);
262 }
263
264 @Test
265 public void shouldDisposeInnerObservable() {
266 final PublishSubject<Object> subject = PublishSubject.create();
267 final Disposable disposable = Observable.just("Leak")
268 .repeatWhen(new Function<Observable<Object>, ObservableSource<Object>>() {
269 @Override
270 public ObservableSource<Object> apply(Observable<Object> completions) throws Exception {
271 return completions.switchMap(new Function<Object, ObservableSource<Object>>() {
272 @Override
273 public ObservableSource<Object> apply(Object ignore) throws Exception {
274 return subject;
275 }
276 });
277 }
278 })
279 .subscribe();
280
281 assertTrue(subject.hasObservers());
282 disposable.dispose();
283 assertFalse(subject.hasObservers());
284 }
285
286 @Test
287 public void repeatWhen() {
288 Observable.error(new TestException())
289 .repeatWhen(new Function<Observable<Object>, ObservableSource<Object>>() {
290 @Override
291 public ObservableSource<Object> apply(Observable<Object> v) throws Exception {
292 return v.delay(10, TimeUnit.SECONDS);
293 }
294 })
295 .test()
296 .awaitDone(5, TimeUnit.SECONDS)
297 .assertFailure(TestException.class);
298 }
299
300 @Test
301 public void whenTake() {
302 Observable.range(1, 3).repeatWhen(new Function<Observable<Object>, ObservableSource<Object>>() {
303 @Override
304 public ObservableSource<Object> apply(Observable<Object> handler) throws Exception {
305 return handler.take(2);
306 }
307 })
308 .test()
309 .assertResult(1, 2, 3, 1, 2, 3);
310 }
311
312 @Test
313 public void handlerError() {
314 Observable.range(1, 3)
315 .repeatWhen(new Function<Observable<Object>, ObservableSource<Object>>() {
316 @Override
317 public ObservableSource<Object> apply(Observable<Object> v) throws Exception {
318 return v.map(new Function<Object, Object>() {
319 @Override
320 public Object apply(Object w) throws Exception {
321 throw new TestException();
322 }
323 });
324 }
325 })
326 .test()
327 .assertFailure(TestException.class, 1, 2, 3);
328 }
329
330 @Test
331 public void noCancelPreviousRepeat() {
332 final AtomicInteger counter = new AtomicInteger();
333
334 Observable<Integer> source = Observable.just(1).doOnDispose(new Action() {
335 @Override
336 public void run() throws Exception {
337 counter.getAndIncrement();
338 }
339 });
340
341 source.repeat(5)
342 .test()
343 .assertResult(1, 1, 1, 1, 1);
344
345 assertEquals(0, counter.get());
346 }
347
348 @Test
349 public void noCancelPreviousRepeatUntil() {
350 final AtomicInteger counter = new AtomicInteger();
351
352 Observable<Integer> source = Observable.just(1).doOnDispose(new Action() {
353 @Override
354 public void run() throws Exception {
355 counter.getAndIncrement();
356 }
357 });
358
359 final AtomicInteger times = new AtomicInteger();
360
361 source.repeatUntil(new BooleanSupplier() {
362 @Override
363 public boolean getAsBoolean() throws Exception {
364 return times.getAndIncrement() == 4;
365 }
366 })
367 .test()
368 .assertResult(1, 1, 1, 1, 1);
369
370 assertEquals(0, counter.get());
371 }
372
373 @Test
374 public void noCancelPreviousRepeatWhen() {
375 final AtomicInteger counter = new AtomicInteger();
376
377 Observable<Integer> source = Observable.just(1).doOnDispose(new Action() {
378 @Override
379 public void run() throws Exception {
380 counter.getAndIncrement();
381 }
382 });
383
384 final AtomicInteger times = new AtomicInteger();
385
386 source.repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
387 @Override
388 public ObservableSource<?> apply(Observable<Object> e) throws Exception {
389 return e.takeWhile(new Predicate<Object>() {
390 @Override
391 public boolean test(Object v) throws Exception {
392 return times.getAndIncrement() < 4;
393 }
394 });
395 }
396 })
397 .test()
398 .assertResult(1, 1, 1, 1, 1);
399
400 assertEquals(0, counter.get());
401 }
402
403 @Test
404 public void repeatFloodNoSubscriptionError() {
405 List<Throwable> errors = TestHelper.trackPluginErrors();
406
407 try {
408 final PublishSubject<Integer> source = PublishSubject.create();
409 final PublishSubject<Integer> signaller = PublishSubject.create();
410
411 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
412
413 TestObserver<Integer> to = source.take(1)
414 .repeatWhen(new Function<Observable<Object>, ObservableSource<Integer>>() {
415 @Override
416 public ObservableSource<Integer> apply(Observable<Object> v)
417 throws Exception {
418 return signaller;
419 }
420 }).test();
421
422 Runnable r1 = new Runnable() {
423 @Override
424 public void run() {
425 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
426 source.onNext(1);
427 }
428 }
429 };
430 Runnable r2 = new Runnable() {
431 @Override
432 public void run() {
433 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
434 signaller.onNext(1);
435 }
436 }
437 };
438
439 TestHelper.race(r1, r2);
440
441 to.dispose();
442 }
443
444 if (!errors.isEmpty()) {
445 for (Throwable e : errors) {
446 e.printStackTrace();
447 }
448 fail(errors + "");
449 }
450 } finally {
451 RxJavaPlugins.reset();
452 }
453 }
454 }