Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeMergeArrayTest.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.*;
19
20 import org.junit.Test;
21 import org.reactivestreams.Subscription;
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.internal.operators.maybe.MaybeMergeArray.MergeMaybeObserver;
27 import io.reactivex.rxjava3.operators.QueueFuseable;
28 import io.reactivex.rxjava3.operators.QueueSubscription;
29 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
30 import io.reactivex.rxjava3.subjects.*;
31 import io.reactivex.rxjava3.subscribers.TestSubscriber;
32 import io.reactivex.rxjava3.testsupport.*;
33
34 public class MaybeMergeArrayTest extends RxJavaTest {
35
36 @Test
37 public void normal() {
38 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.SYNC);
39
40 Maybe.mergeArray(Maybe.just(1), Maybe.just(2))
41 .subscribe(ts);
42 ts
43 .assertFuseable()
44 .assertFusionMode(QueueFuseable.NONE)
45 .assertResult(1, 2);
46 }
47
48 @Test
49 public void fusedPollMixed() {
50 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
51
52 Maybe.mergeArray(Maybe.just(1), Maybe.<Integer>empty(), Maybe.just(2))
53 .subscribe(ts);
54 ts
55 .assertFuseable()
56 .assertFusionMode(QueueFuseable.ASYNC)
57 .assertResult(1, 2);
58 }
59
60 @SuppressWarnings("unchecked")
61 @Test
62 public void fusedEmptyCheck() {
63 Maybe.mergeArray(Maybe.just(1), Maybe.<Integer>empty(), Maybe.just(2))
64 .subscribe(new FlowableSubscriber<Integer>() {
65 QueueSubscription<Integer> qs;
66 @Override
67 public void onSubscribe(Subscription s) {
68 qs = (QueueSubscription<Integer>)s;
69
70 assertEquals(QueueFuseable.ASYNC, qs.requestFusion(QueueFuseable.ANY));
71 }
72
73 @Override
74 public void onNext(Integer value) {
75 assertFalse(qs.isEmpty());
76
77 qs.clear();
78
79 assertTrue(qs.isEmpty());
80
81 qs.cancel();
82 }
83
84 @Override
85 public void onError(Throwable e) {
86 }
87
88 @Override
89 public void onComplete() {
90 }
91 });
92 }
93
94 @Test
95 public void cancel() {
96 TestSubscriber<Integer> ts = new TestSubscriber<>(0L);
97
98 Maybe.mergeArray(Maybe.just(1), Maybe.<Integer>empty(), Maybe.just(2))
99 .subscribe(ts);
100
101 ts.cancel();
102 ts.request(10);
103
104 ts.assertEmpty();
105 }
106
107 @Test
108 public void firstErrors() {
109 TestSubscriber<Integer> ts = new TestSubscriber<>(0L);
110
111 Maybe.mergeArray(Maybe.<Integer>error(new TestException()), Maybe.<Integer>empty(), Maybe.just(2))
112 .subscribe(ts);
113
114 ts.assertFailure(TestException.class);
115 }
116
117 @Test
118 public void errorFused() {
119 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
120
121 Maybe.mergeArray(Maybe.<Integer>error(new TestException()), Maybe.just(2))
122 .subscribe(ts);
123 ts
124 .assertFuseable()
125 .assertFusionMode(QueueFuseable.ASYNC)
126 .assertFailure(TestException.class);
127 }
128
129 @Test
130 public void errorRace() {
131 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
132 List<Throwable> errors = TestHelper.trackPluginErrors();
133
134 try {
135 final PublishSubject<Integer> ps1 = PublishSubject.create();
136 final PublishSubject<Integer> ps2 = PublishSubject.create();
137
138 TestSubscriber<Integer> ts = Maybe.mergeArray(ps1.singleElement(), ps2.singleElement())
139 .test();
140
141 final TestException ex = new TestException();
142
143 Runnable r1 = new Runnable() {
144 @Override
145 public void run() {
146 ps1.onError(ex);
147 }
148 };
149
150 Runnable r2 = new Runnable() {
151 @Override
152 public void run() {
153 ps2.onError(ex);
154 }
155 };
156
157 TestHelper.race(r1, r2);
158
159 ts.assertFailure(Throwable.class);
160
161 if (!errors.isEmpty()) {
162 TestHelper.assertUndeliverable(errors, 0, TestException.class);
163 }
164 } finally {
165 RxJavaPlugins.reset();
166 }
167 }
168 }
169
170 @Test
171 public void mergeBadSource() {
172 Maybe.mergeArray(new Maybe<Integer>() {
173 @Override
174 protected void subscribeActual(MaybeObserver<? super Integer> observer) {
175 observer.onSubscribe(Disposable.empty());
176 observer.onSuccess(1);
177 observer.onSuccess(2);
178 observer.onSuccess(3);
179 }
180 }, Maybe.never())
181 .test()
182 .assertResult(1, 2);
183 }
184
185 @SuppressWarnings("unchecked")
186 @Test
187 public void smallOffer2Throws() {
188 Maybe.mergeArray(Maybe.never(), Maybe.never())
189 .subscribe(new FlowableSubscriber<Object>() {
190
191 @SuppressWarnings("rawtypes")
192 @Override
193 public void onSubscribe(Subscription s) {
194 MergeMaybeObserver o = (MergeMaybeObserver)s;
195
196 try {
197 o.queue.offer(1, 2);
198 fail("Should have thrown");
199 } catch (UnsupportedOperationException ex) {
200 // expected
201 }
202 }
203
204 @Override
205 public void onNext(Object t) {
206 }
207
208 @Override
209 public void onError(Throwable t) {
210 }
211
212 @Override
213 public void onComplete() {
214 }
215 });
216 }
217
218 @SuppressWarnings("unchecked")
219 @Test
220 public void largeOffer2Throws() {
221 Maybe<Integer>[] a = new Maybe[1024];
222 Arrays.fill(a, Maybe.never());
223 Maybe.mergeArray(a)
224 .subscribe(new FlowableSubscriber<Object>() {
225
226 @SuppressWarnings("rawtypes")
227 @Override
228 public void onSubscribe(Subscription s) {
229 MergeMaybeObserver o = (MergeMaybeObserver)s;
230
231 try {
232 o.queue.offer(1, 2);
233 fail("Should have thrown");
234 } catch (UnsupportedOperationException ex) {
235 // expected
236 }
237
238 o.queue.drop();
239 }
240
241 @Override
242 public void onNext(Object t) {
243 }
244
245 @Override
246 public void onError(Throwable t) {
247 }
248
249 @Override
250 public void onComplete() {
251 }
252 });
253 }
254
255 @Test
256 public void badRequest() {
257 TestHelper.assertBadRequestReported(
258 Maybe.mergeArray(MaybeSubject.create(), MaybeSubject.create())
259 );
260 }
261
262 @Test
263 public void cancel2() {
264 TestHelper.checkDisposed(Maybe.mergeArray(MaybeSubject.create(), MaybeSubject.create()));
265 }
266
267 @Test
268 public void take() {
269 Maybe.mergeArray(Maybe.just(1), Maybe.empty(), Maybe.just(2))
270 .doOnSubscribe(s -> s.request(Long.MAX_VALUE))
271 .take(1)
272 .test()
273 .assertResult(1);
274 }
275 }