Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeConcatArrayTest.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.assertEquals;
17
18 import java.io.IOException;
19 import java.util.List;
20
21 import org.junit.Test;
22
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.plugins.RxJavaPlugins;
27 import io.reactivex.rxjava3.subjects.MaybeSubject;
28 import io.reactivex.rxjava3.subscribers.TestSubscriber;
29 import io.reactivex.rxjava3.testsupport.TestHelper;
30
31 public class MaybeConcatArrayTest extends RxJavaTest {
32
33 @Test
34 public void cancel() {
35 Maybe.concatArray(Maybe.just(1), Maybe.just(2))
36 .take(1)
37 .test()
38 .assertResult(1);
39 }
40
41 @Test
42 public void cancelDelayError() {
43 Maybe.concatArrayDelayError(Maybe.just(1), Maybe.just(2))
44 .take(1)
45 .test()
46 .assertResult(1);
47 }
48
49 @Test
50 public void backpressure() {
51 TestSubscriber<Integer> ts = Maybe.concatArray(Maybe.just(1), Maybe.just(2))
52 .test(0L);
53
54 ts.assertEmpty();
55
56 ts.request(1);
57
58 ts.assertValue(1);
59
60 ts.request(2);
61
62 ts.assertResult(1, 2);
63 }
64
65 @Test
66 public void backpressureDelayError() {
67 TestSubscriber<Integer> ts = Maybe.concatArrayDelayError(Maybe.just(1), Maybe.just(2))
68 .test(0L);
69
70 ts.assertEmpty();
71
72 ts.request(1);
73
74 ts.assertValue(1);
75
76 ts.request(2);
77
78 ts.assertResult(1, 2);
79 }
80
81 @Test
82 public void requestCancelRace() {
83 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
84 final TestSubscriber<Integer> ts = Maybe.concatArray(Maybe.just(1), Maybe.just(2))
85 .test(0L);
86
87 Runnable r1 = new Runnable() {
88 @Override
89 public void run() {
90 ts.cancel();
91 }
92 };
93
94 Runnable r2 = new Runnable() {
95 @Override
96 public void run() {
97 ts.request(1);
98 }
99 };
100
101 TestHelper.race(r1, r2);
102 }
103 }
104
105 @Test
106 public void requestCancelRaceDelayError() {
107 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
108 final TestSubscriber<Integer> ts = Maybe.concatArrayDelayError(Maybe.just(1), Maybe.just(2))
109 .test(0L);
110
111 Runnable r1 = new Runnable() {
112 @Override
113 public void run() {
114 ts.cancel();
115 }
116 };
117
118 Runnable r2 = new Runnable() {
119 @Override
120 public void run() {
121 ts.request(1);
122 }
123 };
124
125 TestHelper.race(r1, r2);
126 }
127 }
128
129 @Test
130 public void errorAfterTermination() {
131 List<Throwable> errors = TestHelper.trackPluginErrors();
132 try {
133 final MaybeObserver<?>[] o = { null };
134 Maybe.concatArrayDelayError(Maybe.just(1),
135 Maybe.error(new IOException()),
136 new Maybe<Integer>() {
137 @Override
138 protected void subscribeActual(MaybeObserver<? super Integer> observer) {
139 observer.onSubscribe(Disposable.empty());
140 observer.onSuccess(2);
141 o[0] = observer;
142 }
143 })
144 .test()
145 .assertFailure(IOException.class, 1, 2);
146
147 o[0].onError(new TestException());
148
149 TestHelper.assertUndeliverable(errors, 0, TestException.class);
150 } finally {
151 RxJavaPlugins.reset();
152 }
153 }
154
155 @Test
156 public void noSubsequentSubscription() {
157 final int[] calls = { 0 };
158
159 Maybe<Integer> source = Maybe.create(new MaybeOnSubscribe<Integer>() {
160 @Override
161 public void subscribe(MaybeEmitter<Integer> s) throws Exception {
162 calls[0]++;
163 s.onSuccess(1);
164 }
165 });
166
167 Maybe.concatArray(source, source).firstElement()
168 .test()
169 .assertResult(1);
170
171 assertEquals(1, calls[0]);
172 }
173
174 @Test
175 public void noSubsequentSubscriptionDelayError() {
176 final int[] calls = { 0 };
177
178 Maybe<Integer> source = Maybe.create(new MaybeOnSubscribe<Integer>() {
179 @Override
180 public void subscribe(MaybeEmitter<Integer> s) throws Exception {
181 calls[0]++;
182 s.onSuccess(1);
183 }
184 });
185
186 Maybe.concatArrayDelayError(source, source).firstElement()
187 .test()
188 .assertResult(1);
189
190 assertEquals(1, calls[0]);
191 }
192
193 @Test
194 public void badRequest() {
195 TestHelper.assertBadRequestReported(Maybe.concatArray(MaybeSubject.create(), MaybeSubject.create()));
196 }
197
198 @Test
199 public void badRequestDelayError() {
200 TestHelper.assertBadRequestReported(Maybe.concatArrayDelayError(MaybeSubject.create(), MaybeSubject.create()));
201 }
202
203 @Test
204 public void mixed() {
205 Maybe.concatArray(
206 Maybe.just(1),
207 Maybe.empty(),
208 Maybe.just(2),
209 Maybe.empty(),
210 Maybe.empty()
211 )
212 .test()
213 .assertResult(1, 2);
214 }
215
216 @Test
217 public void requestBeforeSuccess() {
218 MaybeSubject<Integer> ms = MaybeSubject.create();
219 TestSubscriber<Integer> ts = Maybe.concatArray(ms, ms)
220 .test();
221
222 ts.assertEmpty();
223
224 ms.onSuccess(1);
225
226 ts.assertResult(1, 1);
227 }
228
229 @Test
230 public void requestBeforeComplete() {
231 MaybeSubject<Integer> ms = MaybeSubject.create();
232 TestSubscriber<Integer> ts = Maybe.concatArray(ms, ms)
233 .test();
234
235 ts.assertEmpty();
236
237 ms.onComplete();
238
239 ts.assertResult();
240 }
241
242 @Test
243 public void requestBeforeSuccessDelayError() {
244 MaybeSubject<Integer> ms = MaybeSubject.create();
245 TestSubscriber<Integer> ts = Maybe.concatArrayDelayError(ms, ms)
246 .test();
247
248 ts.assertEmpty();
249
250 ms.onSuccess(1);
251
252 ts.assertResult(1, 1);
253 }
254
255 @Test
256 public void requestBeforeCompleteDelayError() {
257 MaybeSubject<Integer> ms = MaybeSubject.create();
258 TestSubscriber<Integer> ts = Maybe.concatArrayDelayError(ms, ms)
259 .test();
260
261 ts.assertEmpty();
262
263 ms.onComplete();
264
265 ts.assertResult();
266 }
267 }