Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeTimeoutPublisherTest.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.TimeoutException;
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.functions.Function;
27 import io.reactivex.rxjava3.observers.TestObserver;
28 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
29 import io.reactivex.rxjava3.processors.PublishProcessor;
30 import io.reactivex.rxjava3.testsupport.*;
31
32 public class MaybeTimeoutPublisherTest extends RxJavaTest {
33
34 @Test
35 public void mainError() {
36 PublishProcessor<Integer> pp1 = PublishProcessor.create();
37 PublishProcessor<Integer> pp2 = PublishProcessor.create();
38
39 TestObserver<Integer> to = pp1.singleElement().timeout(pp2).test();
40
41 assertTrue(pp1.hasSubscribers());
42 assertTrue(pp2.hasSubscribers());
43
44 pp1.onError(new TestException());
45
46 assertFalse(pp1.hasSubscribers());
47 assertFalse(pp2.hasSubscribers());
48
49 to.assertFailure(TestException.class);
50 }
51
52 @Test
53 public void otherError() {
54 PublishProcessor<Integer> pp1 = PublishProcessor.create();
55 PublishProcessor<Integer> pp2 = PublishProcessor.create();
56
57 TestObserver<Integer> to = pp1.singleElement().timeout(pp2).test();
58
59 assertTrue(pp1.hasSubscribers());
60 assertTrue(pp2.hasSubscribers());
61
62 pp2.onError(new TestException());
63
64 assertFalse(pp1.hasSubscribers());
65 assertFalse(pp2.hasSubscribers());
66
67 to.assertFailure(TestException.class);
68 }
69
70 @Test
71 public void fallbackError() {
72 PublishProcessor<Integer> pp1 = PublishProcessor.create();
73 PublishProcessor<Integer> pp2 = PublishProcessor.create();
74
75 TestObserver<Integer> to = pp1.singleElement().timeout(pp2, Maybe.<Integer>error(new TestException())).test();
76
77 assertTrue(pp1.hasSubscribers());
78 assertTrue(pp2.hasSubscribers());
79
80 pp2.onNext(1);
81 pp2.onComplete();
82
83 assertFalse(pp1.hasSubscribers());
84 assertFalse(pp2.hasSubscribers());
85
86 to.assertFailure(TestException.class);
87 }
88
89 @Test
90 public void fallbackComplete() {
91 PublishProcessor<Integer> pp1 = PublishProcessor.create();
92 PublishProcessor<Integer> pp2 = PublishProcessor.create();
93
94 TestObserver<Integer> to = pp1.singleElement().timeout(pp2, Maybe.<Integer>empty()).test();
95
96 assertTrue(pp1.hasSubscribers());
97 assertTrue(pp2.hasSubscribers());
98
99 pp2.onNext(1);
100 pp2.onComplete();
101
102 assertFalse(pp1.hasSubscribers());
103 assertFalse(pp2.hasSubscribers());
104
105 to.assertResult();
106 }
107
108 @Test
109 public void mainComplete() {
110 PublishProcessor<Integer> pp1 = PublishProcessor.create();
111 PublishProcessor<Integer> pp2 = PublishProcessor.create();
112
113 TestObserver<Integer> to = pp1.singleElement().timeout(pp2).test();
114
115 assertTrue(pp1.hasSubscribers());
116 assertTrue(pp2.hasSubscribers());
117
118 pp1.onComplete();
119
120 assertFalse(pp1.hasSubscribers());
121 assertFalse(pp2.hasSubscribers());
122
123 to.assertResult();
124 }
125
126 @Test
127 public void otherComplete() {
128 PublishProcessor<Integer> pp1 = PublishProcessor.create();
129 PublishProcessor<Integer> pp2 = PublishProcessor.create();
130
131 TestObserver<Integer> to = pp1.singleElement().timeout(pp2).test();
132
133 assertTrue(pp1.hasSubscribers());
134 assertTrue(pp2.hasSubscribers());
135
136 pp2.onComplete();
137
138 assertFalse(pp1.hasSubscribers());
139 assertFalse(pp2.hasSubscribers());
140
141 to.assertFailure(TimeoutException.class);
142 }
143
144 @Test
145 public void dispose() {
146 PublishProcessor<Integer> pp1 = PublishProcessor.create();
147 PublishProcessor<Integer> pp2 = PublishProcessor.create();
148
149 TestHelper.checkDisposed(pp1.singleElement().timeout(pp2));
150 }
151
152 @Test
153 public void dispose2() {
154 PublishProcessor<Integer> pp1 = PublishProcessor.create();
155 PublishProcessor<Integer> pp2 = PublishProcessor.create();
156
157 TestHelper.checkDisposed(pp1.singleElement().timeout(pp2, Maybe.just(1)));
158 }
159
160 @Test
161 public void onErrorRace() {
162 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
163 TestHelper.trackPluginErrors();
164 try {
165 final PublishProcessor<Integer> pp1 = PublishProcessor.create();
166 final PublishProcessor<Integer> pp2 = PublishProcessor.create();
167
168 TestObserver<Integer> to = pp1.singleElement().timeout(pp2).test();
169
170 final TestException ex = new TestException();
171
172 Runnable r1 = new Runnable() {
173 @Override
174 public void run() {
175 pp1.onError(ex);
176 }
177 };
178 Runnable r2 = new Runnable() {
179 @Override
180 public void run() {
181 pp2.onError(ex);
182 }
183 };
184
185 TestHelper.race(r1, r2);
186
187 to.assertFailure(TestException.class);
188 } finally {
189 RxJavaPlugins.reset();
190 }
191 }
192 }
193
194 @Test
195 public void onCompleteRace() {
196 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
197 final PublishProcessor<Integer> pp1 = PublishProcessor.create();
198 final PublishProcessor<Integer> pp2 = PublishProcessor.create();
199
200 TestObserverEx<Integer> to = pp1.singleElement().timeout(pp2).to(TestHelper.<Integer>testConsumer());
201
202 Runnable r1 = new Runnable() {
203 @Override
204 public void run() {
205 pp1.onComplete();
206 }
207 };
208 Runnable r2 = new Runnable() {
209 @Override
210 public void run() {
211 pp2.onComplete();
212 }
213 };
214
215 TestHelper.race(r1, r2);
216
217 to.assertSubscribed().assertNoValues();
218
219 if (to.errors().size() != 0) {
220 to.assertError(TimeoutException.class).assertNotComplete();
221 } else {
222 to.assertNoErrors().assertComplete();
223 }
224 }
225 }
226
227 @Test
228 public void badSourceOther() {
229 TestHelper.checkBadSourceFlowable(new Function<Flowable<Integer>, Object>() {
230 @Override
231 public Object apply(Flowable<Integer> f) throws Exception {
232 return Maybe.never().timeout(f, Maybe.just(1));
233 }
234 }, false, null, 1, 1);
235 }
236
237 @Test
238 public void mainSuccessAfterOtherSignal() {
239 PublishProcessor<Integer> pp = PublishProcessor.create();
240
241 new Maybe<Integer>() {
242 @Override
243 protected void subscribeActual(@NonNull MaybeObserver<? super Integer> observer) {
244 observer.onSubscribe(Disposable.empty());
245 pp.onNext(2);
246 observer.onSuccess(1);
247 }
248 }
249 .timeout(pp)
250 .test()
251 .assertFailure(TimeoutException.class);
252 }
253
254 @Test
255 public void mainSuccess() {
256 Maybe.just(1)
257 .timeout(Flowable.never())
258 .test()
259 .assertResult(1);
260 }
261 }