Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeTimeoutTest.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.maybe;
15
16 import static org.junit.Assert.*;
17
18 import java.util.concurrent.*;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.annotations.NonNull;
23 import io.reactivex.rxjava3.core.*;
24 import io.reactivex.rxjava3.disposables.Disposable;
25 import io.reactivex.rxjava3.exceptions.TestException;
26 import io.reactivex.rxjava3.observers.TestObserver;
27 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
28 import io.reactivex.rxjava3.processors.PublishProcessor;
29 import io.reactivex.rxjava3.schedulers.Schedulers;
30 import io.reactivex.rxjava3.subjects.MaybeSubject;
31 import io.reactivex.rxjava3.testsupport.*;
32
33 public class MaybeTimeoutTest extends RxJavaTest {
34
35 @Test
36 public void normal() {
37 Maybe.just(1)
38 .timeout(1, TimeUnit.DAYS)
39 .test()
40 .assertResult(1);
41 }
42
43 @Test
44 public void normalMaybe() {
45 Maybe.just(1)
46 .timeout(Maybe.timer(1, TimeUnit.DAYS))
47 .test()
48 .assertResult(1);
49 }
50
51 @Test
52 public void never() {
53 Maybe.never()
54 .timeout(1, TimeUnit.MILLISECONDS)
55 .test()
56 .awaitDone(5, TimeUnit.SECONDS)
57 .assertFailure(TimeoutException.class);
58 }
59
60 @Test
61 public void neverMaybe() {
62 Maybe.never()
63 .timeout(Maybe.timer(1, TimeUnit.MILLISECONDS))
64 .test()
65 .awaitDone(5, TimeUnit.SECONDS)
66 .assertFailure(TimeoutException.class);
67 }
68
69 @Test
70 public void normalFallback() {
71 Maybe.just(1)
72 .timeout(1, TimeUnit.DAYS, Maybe.just(2))
73 .test()
74 .assertResult(1);
75 }
76
77 @Test
78 public void normalMaybeFallback() {
79 Maybe.just(1)
80 .timeout(Maybe.timer(1, TimeUnit.DAYS), Maybe.just(2))
81 .test()
82 .assertResult(1);
83 }
84
85 @Test
86 public void neverFallback() {
87 Maybe.never()
88 .timeout(1, TimeUnit.MILLISECONDS, Maybe.just(2))
89 .test()
90 .awaitDone(5, TimeUnit.SECONDS)
91 .assertResult(2);
92 }
93
94 @Test
95 public void neverMaybeFallback() {
96 Maybe.never()
97 .timeout(Maybe.timer(1, TimeUnit.MILLISECONDS), Maybe.just(2))
98 .test()
99 .awaitDone(5, TimeUnit.SECONDS)
100 .assertResult(2);
101 }
102
103 @Test
104 public void neverFallbackScheduler() {
105 Maybe.never()
106 .timeout(1, TimeUnit.MILLISECONDS, Schedulers.single(), Maybe.just(2))
107 .test()
108 .awaitDone(5, TimeUnit.SECONDS)
109 .assertResult(2);
110 }
111
112 @Test
113 public void neverScheduler() {
114 Maybe.never()
115 .timeout(1, TimeUnit.MILLISECONDS, Schedulers.single())
116 .test()
117 .awaitDone(5, TimeUnit.SECONDS)
118 .assertFailure(TimeoutException.class);
119 }
120
121 @Test
122 public void normalFlowableFallback() {
123 Maybe.just(1)
124 .timeout(Flowable.timer(1, TimeUnit.DAYS), Maybe.just(2))
125 .test()
126 .assertResult(1);
127 }
128
129 @Test
130 public void neverFlowableFallback() {
131 Maybe.never()
132 .timeout(Flowable.timer(1, TimeUnit.MILLISECONDS), Maybe.just(2))
133 .test()
134 .awaitDone(5, TimeUnit.SECONDS)
135 .assertResult(2);
136 }
137
138 @Test
139 public void normalFlowable() {
140 Maybe.just(1)
141 .timeout(Flowable.timer(1, TimeUnit.DAYS))
142 .test()
143 .assertResult(1);
144 }
145
146 @Test
147 public void neverFlowable() {
148 Maybe.never()
149 .timeout(Flowable.timer(1, TimeUnit.MILLISECONDS))
150 .test()
151 .awaitDone(5, TimeUnit.SECONDS)
152 .assertFailure(TimeoutException.class);
153 }
154
155 @Test
156 public void mainError() {
157 PublishProcessor<Integer> pp1 = PublishProcessor.create();
158 PublishProcessor<Integer> pp2 = PublishProcessor.create();
159
160 TestObserver<Integer> to = pp1.singleElement().timeout(pp2.singleElement()).test();
161
162 assertTrue(pp1.hasSubscribers());
163 assertTrue(pp2.hasSubscribers());
164
165 pp1.onError(new TestException());
166
167 assertFalse(pp1.hasSubscribers());
168 assertFalse(pp2.hasSubscribers());
169
170 to.assertFailure(TestException.class);
171 }
172
173 @Test
174 public void otherError() {
175 PublishProcessor<Integer> pp1 = PublishProcessor.create();
176 PublishProcessor<Integer> pp2 = PublishProcessor.create();
177
178 TestObserver<Integer> to = pp1.singleElement().timeout(pp2.singleElement()).test();
179
180 assertTrue(pp1.hasSubscribers());
181 assertTrue(pp2.hasSubscribers());
182
183 pp2.onError(new TestException());
184
185 assertFalse(pp1.hasSubscribers());
186 assertFalse(pp2.hasSubscribers());
187
188 to.assertFailure(TestException.class);
189 }
190
191 @Test
192 public void fallbackError() {
193 PublishProcessor<Integer> pp1 = PublishProcessor.create();
194 PublishProcessor<Integer> pp2 = PublishProcessor.create();
195
196 TestObserver<Integer> to = pp1.singleElement().timeout(pp2.singleElement(), Maybe.<Integer>error(new TestException())).test();
197
198 assertTrue(pp1.hasSubscribers());
199 assertTrue(pp2.hasSubscribers());
200
201 pp2.onNext(1);
202 pp2.onComplete();
203
204 assertFalse(pp1.hasSubscribers());
205 assertFalse(pp2.hasSubscribers());
206
207 to.assertFailure(TestException.class);
208 }
209
210 @Test
211 public void fallbackComplete() {
212 PublishProcessor<Integer> pp1 = PublishProcessor.create();
213 PublishProcessor<Integer> pp2 = PublishProcessor.create();
214
215 TestObserver<Integer> to = pp1.singleElement().timeout(pp2.singleElement(), Maybe.<Integer>empty()).test();
216
217 assertTrue(pp1.hasSubscribers());
218 assertTrue(pp2.hasSubscribers());
219
220 pp2.onNext(1);
221 pp2.onComplete();
222
223 assertFalse(pp1.hasSubscribers());
224 assertFalse(pp2.hasSubscribers());
225
226 to.assertResult();
227 }
228
229 @Test
230 public void mainComplete() {
231 PublishProcessor<Integer> pp1 = PublishProcessor.create();
232 PublishProcessor<Integer> pp2 = PublishProcessor.create();
233
234 TestObserver<Integer> to = pp1.singleElement().timeout(pp2.singleElement()).test();
235
236 assertTrue(pp1.hasSubscribers());
237 assertTrue(pp2.hasSubscribers());
238
239 pp1.onComplete();
240
241 assertFalse(pp1.hasSubscribers());
242 assertFalse(pp2.hasSubscribers());
243
244 to.assertResult();
245 }
246
247 @Test
248 public void otherComplete() {
249 PublishProcessor<Integer> pp1 = PublishProcessor.create();
250 PublishProcessor<Integer> pp2 = PublishProcessor.create();
251
252 TestObserver<Integer> to = pp1.singleElement().timeout(pp2.singleElement()).test();
253
254 assertTrue(pp1.hasSubscribers());
255 assertTrue(pp2.hasSubscribers());
256
257 pp2.onComplete();
258
259 assertFalse(pp1.hasSubscribers());
260 assertFalse(pp2.hasSubscribers());
261
262 to.assertFailure(TimeoutException.class);
263 }
264
265 @Test
266 public void dispose() {
267 PublishProcessor<Integer> pp1 = PublishProcessor.create();
268 PublishProcessor<Integer> pp2 = PublishProcessor.create();
269
270 TestHelper.checkDisposed(pp1.singleElement().timeout(pp2.singleElement()));
271 }
272
273 @Test
274 public void dispose2() {
275 PublishProcessor<Integer> pp1 = PublishProcessor.create();
276 PublishProcessor<Integer> pp2 = PublishProcessor.create();
277
278 TestHelper.checkDisposed(pp1.singleElement().timeout(pp2.singleElement(), Maybe.just(1)));
279 }
280
281 @Test
282 public void onErrorRace() {
283 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
284 TestHelper.trackPluginErrors();
285 try {
286 final PublishProcessor<Integer> pp1 = PublishProcessor.create();
287 final PublishProcessor<Integer> pp2 = PublishProcessor.create();
288
289 TestObserver<Integer> to = pp1.singleElement().timeout(pp2.singleElement()).test();
290
291 final TestException ex = new TestException();
292
293 Runnable r1 = new Runnable() {
294 @Override
295 public void run() {
296 pp1.onError(ex);
297 }
298 };
299 Runnable r2 = new Runnable() {
300 @Override
301 public void run() {
302 pp2.onError(ex);
303 }
304 };
305
306 TestHelper.race(r1, r2);
307
308 to.assertFailure(TestException.class);
309 } finally {
310 RxJavaPlugins.reset();
311 }
312 }
313 }
314
315 @Test
316 public void onCompleteRace() {
317 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
318 final PublishProcessor<Integer> pp1 = PublishProcessor.create();
319 final PublishProcessor<Integer> pp2 = PublishProcessor.create();
320
321 TestObserverEx<Integer> to = pp1.singleElement().timeout(pp2.singleElement()).to(TestHelper.<Integer>testConsumer());
322
323 Runnable r1 = new Runnable() {
324 @Override
325 public void run() {
326 pp1.onComplete();
327 }
328 };
329 Runnable r2 = new Runnable() {
330 @Override
331 public void run() {
332 pp2.onComplete();
333 }
334 };
335
336 TestHelper.race(r1, r2);
337
338 to.assertSubscribed().assertNoValues();
339
340 if (to.errors().size() != 0) {
341 to.assertError(TimeoutException.class).assertNotComplete();
342 } else {
343 to.assertNoErrors().assertComplete();
344 }
345 }
346 }
347
348 @Test
349 public void mainSuccessAfterOtherSignal() {
350 MaybeSubject<Integer> ms = MaybeSubject.create();
351
352 new Maybe<Integer>() {
353 @Override
354 protected void subscribeActual(@NonNull MaybeObserver<? super Integer> observer) {
355 observer.onSubscribe(Disposable.empty());
356 ms.onSuccess(2);
357 observer.onSuccess(1);
358 }
359 }
360 .timeout(ms)
361 .test()
362 .assertFailure(TimeoutException.class);
363 }
364 }