Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleDelayTest.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.single;
15
16 import static org.junit.Assert.assertNotEquals;
17
18 import java.util.List;
19 import java.util.concurrent.*;
20 import java.util.concurrent.atomic.AtomicReference;
21
22 import org.junit.Test;
23 import org.reactivestreams.Subscriber;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.disposables.Disposable;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.functions.*;
29 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
30 import io.reactivex.rxjava3.observers.TestObserver;
31 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
32 import io.reactivex.rxjava3.schedulers.*;
33 import io.reactivex.rxjava3.subjects.*;
34 import io.reactivex.rxjava3.testsupport.TestHelper;
35
36 public class SingleDelayTest extends RxJavaTest {
37 @Test
38 public void delayOnSuccess() {
39 final TestScheduler scheduler = new TestScheduler();
40 final TestObserver<Integer> observer = Single.just(1)
41 .delay(5, TimeUnit.SECONDS, scheduler)
42 .test();
43
44 scheduler.advanceTimeTo(2, TimeUnit.SECONDS);
45 observer.assertNoValues();
46
47 scheduler.advanceTimeTo(5, TimeUnit.SECONDS);
48 observer.assertValue(1);
49 }
50
51 @Test
52 public void delayOnError() {
53 final TestScheduler scheduler = new TestScheduler();
54 final TestObserver<?> observer = Single.error(new TestException())
55 .delay(5, TimeUnit.SECONDS, scheduler)
56 .test();
57
58 scheduler.triggerActions();
59 observer.assertError(TestException.class);
60 }
61
62 @Test
63 public void delayedErrorOnSuccess() {
64 final TestScheduler scheduler = new TestScheduler();
65 final TestObserver<Integer> observer = Single.just(1)
66 .delay(5, TimeUnit.SECONDS, scheduler, true)
67 .test();
68
69 scheduler.advanceTimeTo(2, TimeUnit.SECONDS);
70 observer.assertNoValues();
71
72 scheduler.advanceTimeTo(5, TimeUnit.SECONDS);
73 observer.assertValue(1);
74 }
75
76 @Test
77 public void delayedErrorOnError() {
78 final TestScheduler scheduler = new TestScheduler();
79 final TestObserver<?> observer = Single.error(new TestException())
80 .delay(5, TimeUnit.SECONDS, scheduler, true)
81 .test();
82
83 scheduler.advanceTimeTo(2, TimeUnit.SECONDS);
84 observer.assertNoErrors();
85
86 scheduler.advanceTimeTo(5, TimeUnit.SECONDS);
87 observer.assertError(TestException.class);
88 }
89
90 @Test
91 public void delaySubscriptionCompletable() throws Exception {
92 Single.just(1).delaySubscription(Completable.complete().delay(100, TimeUnit.MILLISECONDS))
93 .test()
94 .awaitDone(5, TimeUnit.SECONDS)
95 .assertResult(1);
96 }
97
98 @Test
99 public void delaySubscriptionObservable() throws Exception {
100 Single.just(1).delaySubscription(Observable.timer(100, TimeUnit.MILLISECONDS))
101 .test()
102 .awaitDone(5, TimeUnit.SECONDS)
103 .assertResult(1);
104 }
105
106 @Test
107 public void delaySubscriptionFlowable() throws Exception {
108 Single.just(1).delaySubscription(Flowable.timer(100, TimeUnit.MILLISECONDS))
109 .test()
110 .awaitDone(5, TimeUnit.SECONDS)
111 .assertResult(1);
112 }
113
114 @Test
115 public void delaySubscriptionSingle() throws Exception {
116 Single.just(1).delaySubscription(Single.timer(100, TimeUnit.MILLISECONDS))
117 .test()
118 .awaitDone(5, TimeUnit.SECONDS)
119 .assertResult(1);
120 }
121
122 @Test
123 public void delaySubscriptionTime() throws Exception {
124 Single.just(1).delaySubscription(100, TimeUnit.MILLISECONDS)
125 .test()
126 .awaitDone(5, TimeUnit.SECONDS)
127 .assertResult(1);
128 }
129
130 @Test
131 public void delaySubscriptionTimeCustomScheduler() throws Exception {
132 Single.just(1).delaySubscription(100, TimeUnit.MILLISECONDS, Schedulers.io())
133 .test()
134 .awaitDone(5, TimeUnit.SECONDS)
135 .assertResult(1);
136 }
137
138 @Test
139 public void onErrorCalledOnScheduler() throws Exception {
140 final CountDownLatch latch = new CountDownLatch(1);
141 final AtomicReference<Thread> thread = new AtomicReference<>();
142
143 Single.<String>error(new Exception())
144 .delay(0, TimeUnit.MILLISECONDS, Schedulers.newThread())
145 .doOnError(new Consumer<Throwable>() {
146 @Override
147 public void accept(Throwable throwable) throws Exception {
148 thread.set(Thread.currentThread());
149 latch.countDown();
150 }
151 })
152 .onErrorResumeWith(Single.just(""))
153 .subscribe();
154
155 latch.await();
156
157 assertNotEquals(Thread.currentThread(), thread.get());
158 }
159
160 @Test
161 public void withPublisherDispose() {
162 TestHelper.checkDisposed(PublishSubject.create().singleOrError().delaySubscription(Flowable.just(1)));
163 }
164
165 @Test
166 public void withPublisherError() {
167 Single.just(1)
168 .delaySubscription(Flowable.error(new TestException()))
169 .test()
170 .assertFailure(TestException.class);
171 }
172
173 @Test
174 public void withPublisherError2() {
175 List<Throwable> errors = TestHelper.trackPluginErrors();
176
177 try {
178 Single.just(1)
179 .delaySubscription(new Flowable<Integer>() {
180 @Override
181 protected void subscribeActual(Subscriber<? super Integer> s) {
182 s.onSubscribe(new BooleanSubscription());
183 s.onNext(1);
184 s.onError(new TestException());
185 }
186 })
187 .test()
188 .assertResult(1);
189
190 TestHelper.assertUndeliverable(errors, 0, TestException.class);
191 } finally {
192 RxJavaPlugins.reset();
193 }
194 }
195
196 @Test
197 public void withObservableDispose() {
198 TestHelper.checkDisposed(PublishSubject.create().singleOrError().delaySubscription(Observable.just(1)));
199 }
200
201 @Test
202 public void withObservableError() {
203 Single.just(1)
204 .delaySubscription(Observable.error(new TestException()))
205 .test()
206 .assertFailure(TestException.class);
207 }
208
209 @Test
210 public void withObservableError2() {
211 List<Throwable> errors = TestHelper.trackPluginErrors();
212
213 try {
214 Single.just(1)
215 .delaySubscription(new Observable<Integer>() {
216 @Override
217 protected void subscribeActual(Observer<? super Integer> observer) {
218 observer.onSubscribe(Disposable.empty());
219 observer.onNext(1);
220 observer.onError(new TestException());
221 }
222 })
223 .test()
224 .assertResult(1);
225
226 TestHelper.assertUndeliverable(errors, 0, TestException.class);
227 } finally {
228 RxJavaPlugins.reset();
229 }
230 }
231
232 @Test
233 public void withSingleErrors() {
234 Single.just(1)
235 .delaySubscription(Single.error(new TestException()))
236 .test()
237 .assertFailure(TestException.class);
238 }
239
240 @Test
241 public void withSingleDispose() {
242 TestHelper.checkDisposed(Single.just(1).delaySubscription(Single.just(2)));
243 }
244
245 @Test
246 public void withCompletableDispose() {
247 TestHelper.checkDisposed(Completable.complete().andThen(Single.just(1)));
248 }
249
250 @Test
251 public void withCompletableDoubleOnSubscribe() {
252
253 TestHelper.checkDoubleOnSubscribeCompletableToSingle(new Function<Completable, Single<Object>>() {
254 @Override
255 public Single<Object> apply(Completable c) throws Exception {
256 return c.andThen(Single.just((Object)1));
257 }
258 });
259
260 }
261
262 @Test
263 public void withSingleDoubleOnSubscribe() {
264
265 TestHelper.checkDoubleOnSubscribeSingle(new Function<Single<Object>, Single<Object>>() {
266 @Override
267 public Single<Object> apply(Single<Object> s) throws Exception {
268 return Single.just((Object)1).delaySubscription(s);
269 }
270 });
271
272 }
273
274 @Test
275 public void withPublisherDoubleOnSubscribe() {
276 TestHelper.checkDoubleOnSubscribeFlowableToSingle(
277 f -> SingleSubject.create().delaySubscription(f));
278 }
279
280 @Test
281 public void withObservableDoubleOnSubscribe() {
282 TestHelper.checkDoubleOnSubscribeObservableToSingle(
283 o -> SingleSubject.create().delaySubscription(o));
284 }
285 }