Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeZipArrayTest.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 import java.util.concurrent.atomic.AtomicReference;
20
21 import org.junit.Test;
22
23 import io.reactivex.rxjava3.annotations.NonNull;
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.disposables.Disposable;
26 import io.reactivex.rxjava3.exceptions.TestException;
27 import io.reactivex.rxjava3.functions.*;
28 import io.reactivex.rxjava3.internal.functions.Functions;
29 import io.reactivex.rxjava3.observers.TestObserver;
30 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
31 import io.reactivex.rxjava3.processors.PublishProcessor;
32 import io.reactivex.rxjava3.subjects.MaybeSubject;
33 import io.reactivex.rxjava3.testsupport.TestHelper;
34
35 public class MaybeZipArrayTest extends RxJavaTest {
36
37 final BiFunction<Object, Object, Object> addString = new BiFunction<Object, Object, Object>() {
38 @Override
39 public Object apply(Object a, Object b) throws Exception {
40 return "" + a + b;
41 }
42 };
43
44 final Function3<Object, Object, Object, Object> addString3 = new Function3<Object, Object, Object, Object>() {
45 @Override
46 public Object apply(Object a, Object b, Object c) throws Exception {
47 return "" + a + b + c;
48 }
49 };
50
51 @Test
52 public void firstError() {
53 Maybe.zip(Maybe.error(new TestException()), Maybe.just(1), addString)
54 .test()
55 .assertFailure(TestException.class);
56 }
57
58 @Test
59 public void secondError() {
60 Maybe.zip(Maybe.just(1), Maybe.<Integer>error(new TestException()), addString)
61 .test()
62 .assertFailure(TestException.class);
63 }
64
65 @Test
66 public void dispose() {
67 PublishProcessor<Integer> pp = PublishProcessor.create();
68
69 TestObserver<Object> to = Maybe.zip(pp.singleElement(), pp.singleElement(), addString)
70 .test();
71
72 assertTrue(pp.hasSubscribers());
73
74 to.dispose();
75
76 assertFalse(pp.hasSubscribers());
77 }
78
79 @Test
80 public void zipperThrows() {
81 Maybe.zip(Maybe.just(1), Maybe.just(2), new BiFunction<Integer, Integer, Object>() {
82 @Override
83 public Object apply(Integer a, Integer b) throws Exception {
84 throw new TestException();
85 }
86 })
87 .test()
88 .assertFailure(TestException.class);
89 }
90
91 @Test
92 public void zipperReturnsNull() {
93 Maybe.zip(Maybe.just(1), Maybe.just(2), new BiFunction<Integer, Integer, Object>() {
94 @Override
95 public Object apply(Integer a, Integer b) throws Exception {
96 return null;
97 }
98 })
99 .test()
100 .assertFailure(NullPointerException.class);
101 }
102
103 @Test
104 public void middleError() {
105 PublishProcessor<Integer> pp0 = PublishProcessor.create();
106 PublishProcessor<Integer> pp1 = PublishProcessor.create();
107
108 TestObserver<Object> to = Maybe.zip(pp0.singleElement(), pp1.singleElement(), pp0.singleElement(), addString3)
109 .test();
110
111 pp1.onError(new TestException());
112
113 assertFalse(pp0.hasSubscribers());
114
115 to.assertFailure(TestException.class);
116 }
117
118 @Test
119 public void innerErrorRace() {
120 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
121 List<Throwable> errors = TestHelper.trackPluginErrors();
122 try {
123 final PublishProcessor<Integer> pp0 = PublishProcessor.create();
124 final PublishProcessor<Integer> pp1 = PublishProcessor.create();
125
126 final TestObserver<Object> to = Maybe.zip(pp0.singleElement(), pp1.singleElement(), addString)
127 .test();
128
129 final TestException ex = new TestException();
130
131 Runnable r1 = new Runnable() {
132 @Override
133 public void run() {
134 pp0.onError(ex);
135 }
136 };
137
138 Runnable r2 = new Runnable() {
139 @Override
140 public void run() {
141 pp1.onError(ex);
142 }
143 };
144
145 TestHelper.race(r1, r2);
146
147 to.assertFailure(TestException.class);
148
149 if (!errors.isEmpty()) {
150 TestHelper.assertUndeliverable(errors, 0, TestException.class);
151 }
152 } finally {
153 RxJavaPlugins.reset();
154 }
155 }
156 }
157
158 @Test(expected = NullPointerException.class)
159 public void zipArrayOneIsNull() {
160 Maybe.zipArray(new Function<Object[], Object>() {
161 @Override
162 public Object apply(Object[] v) {
163 return 1;
164 }
165 }, Maybe.just(1), null)
166 .blockingGet();
167 }
168
169 @Test
170 public void singleSourceZipperReturnsNull() {
171 Maybe.zipArray(Functions.justFunction(null), Maybe.just(1))
172 .to(TestHelper.<Object>testConsumer())
173 .assertFailureAndMessage(NullPointerException.class, "The zipper returned a null value");
174 }
175
176 @Test
177 public void dispose2() {
178 TestHelper.checkDisposed(Maybe.zipArray(v -> v, MaybeSubject.create(), MaybeSubject.create()));
179 }
180
181 @Test
182 public void bothComplete() {
183 AtomicReference<MaybeObserver<? super Integer>> ref1 = new AtomicReference<>();
184 AtomicReference<MaybeObserver<? super Integer>> ref2 = new AtomicReference<>();
185
186 Maybe<Integer> m1 = new Maybe<Integer>() {
187 @Override
188 protected void subscribeActual(@NonNull MaybeObserver<? super Integer> observer) {
189 ref1.set(observer);
190 }
191 };
192 Maybe<Integer> m2 = new Maybe<Integer>() {
193 @Override
194 protected void subscribeActual(@NonNull MaybeObserver<? super Integer> observer) {
195 ref2.set(observer);
196 }
197 };
198
199 TestObserver<Object[]> to = Maybe.zipArray(v -> v, m1, m2)
200 .test();
201
202 ref1.get().onSubscribe(Disposable.empty());
203 ref2.get().onSubscribe(Disposable.empty());
204
205 ref1.get().onComplete();
206 ref2.get().onComplete();
207
208 to.assertResult();
209 }
210
211 @Test
212 public void bothSucceed() {
213 Maybe.zipArray(v -> Arrays.asList(v), Maybe.just(1), Maybe.just(2))
214 .test()
215 .assertResult(Arrays.asList(1, 2));
216 }
217
218 @Test
219 public void oneSourceOnly() {
220 Maybe.zipArray(v -> Arrays.asList(v), Maybe.just(1))
221 .test()
222 .assertResult(Arrays.asList(1));
223 }
224
225 @Test
226 public void onSuccessAfterDispose() {
227 AtomicReference<MaybeObserver<? super Integer>> emitter = new AtomicReference<>();
228
229 TestObserver<List<Object>> to = Maybe.zipArray(Arrays::asList,
230 (MaybeSource<Integer>)o -> emitter.set(o), Maybe.<Integer>never())
231 .test();
232
233 emitter.get().onSubscribe(Disposable.empty());
234
235 to.dispose();
236
237 emitter.get().onSuccess(1);
238
239 to.assertEmpty();
240 }
241 }