Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableToMapTest.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.observable;
15
16 import static org.mockito.ArgumentMatchers.any;
17 import static org.mockito.Mockito.*;
18
19 import java.util.*;
20
21 import org.junit.*;
22
23 import io.reactivex.rxjava3.core.*;
24 import io.reactivex.rxjava3.core.Observable;
25 import io.reactivex.rxjava3.core.Observer;
26 import io.reactivex.rxjava3.functions.*;
27 import io.reactivex.rxjava3.testsupport.TestHelper;
28
29 public class ObservableToMapTest extends RxJavaTest {
30 Observer<Object> objectObserver;
31 SingleObserver<Object> singleObserver;
32
33 @Before
34 public void before() {
35 objectObserver = TestHelper.mockObserver();
36 singleObserver = TestHelper.mockSingleObserver();
37 }
38
39 Function<String, Integer> lengthFunc = new Function<String, Integer>() {
40 @Override
41 public Integer apply(String t1) {
42 return t1.length();
43 }
44 };
45 Function<String, String> duplicate = new Function<String, String>() {
46 @Override
47 public String apply(String t1) {
48 return t1 + t1;
49 }
50 };
51
52 @Test
53 public void toMapObservable() {
54 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
55
56 Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc).toObservable();
57
58 Map<Integer, String> expected = new HashMap<>();
59 expected.put(1, "a");
60 expected.put(2, "bb");
61 expected.put(3, "ccc");
62 expected.put(4, "dddd");
63
64 mapped.subscribe(objectObserver);
65
66 verify(objectObserver, never()).onError(any(Throwable.class));
67 verify(objectObserver, times(1)).onNext(expected);
68 verify(objectObserver, times(1)).onComplete();
69 }
70
71 @Test
72 public void toMapWithValueSelectorObservable() {
73 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
74
75 Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, duplicate).toObservable();
76
77 Map<Integer, String> expected = new HashMap<>();
78 expected.put(1, "aa");
79 expected.put(2, "bbbb");
80 expected.put(3, "cccccc");
81 expected.put(4, "dddddddd");
82
83 mapped.subscribe(objectObserver);
84
85 verify(objectObserver, never()).onError(any(Throwable.class));
86 verify(objectObserver, times(1)).onNext(expected);
87 verify(objectObserver, times(1)).onComplete();
88 }
89
90 @Test
91 public void toMapWithErrorObservable() {
92 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
93
94 Function<String, Integer> lengthFuncErr = new Function<String, Integer>() {
95 @Override
96 public Integer apply(String t1) {
97 if ("bb".equals(t1)) {
98 throw new RuntimeException("Forced Failure");
99 }
100 return t1.length();
101 }
102 };
103 Observable<Map<Integer, String>> mapped = source.toMap(lengthFuncErr).toObservable();
104
105 Map<Integer, String> expected = new HashMap<>();
106 expected.put(1, "a");
107 expected.put(2, "bb");
108 expected.put(3, "ccc");
109 expected.put(4, "dddd");
110
111 mapped.subscribe(objectObserver);
112
113 verify(objectObserver, never()).onNext(expected);
114 verify(objectObserver, never()).onComplete();
115 verify(objectObserver, times(1)).onError(any(Throwable.class));
116
117 }
118
119 @Test
120 public void toMapWithErrorInValueSelectorObservable() {
121 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
122
123 Function<String, String> duplicateErr = new Function<String, String>() {
124 @Override
125 public String apply(String t1) {
126 if ("bb".equals(t1)) {
127 throw new RuntimeException("Forced failure");
128 }
129 return t1 + t1;
130 }
131 };
132
133 Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, duplicateErr).toObservable();
134
135 Map<Integer, String> expected = new HashMap<>();
136 expected.put(1, "aa");
137 expected.put(2, "bbbb");
138 expected.put(3, "cccccc");
139 expected.put(4, "dddddddd");
140
141 mapped.subscribe(objectObserver);
142
143 verify(objectObserver, never()).onNext(expected);
144 verify(objectObserver, never()).onComplete();
145 verify(objectObserver, times(1)).onError(any(Throwable.class));
146
147 }
148
149 @Test
150 public void toMapWithFactoryObservable() {
151 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
152
153 Supplier<Map<Integer, String>> mapFactory = new Supplier<Map<Integer, String>>() {
154 @Override
155 public Map<Integer, String> get() {
156 return new LinkedHashMap<Integer, String>() {
157
158 private static final long serialVersionUID = -3296811238780863394L;
159
160 @Override
161 protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
162 return size() > 3;
163 }
164 };
165 }
166 };
167
168 Function<String, Integer> lengthFunc = new Function<String, Integer>() {
169 @Override
170 public Integer apply(String t1) {
171 return t1.length();
172 }
173 };
174 Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, new Function<String, String>() {
175 @Override
176 public String apply(String v) {
177 return v;
178 }
179 }, mapFactory).toObservable();
180
181 Map<Integer, String> expected = new LinkedHashMap<>();
182 expected.put(2, "bb");
183 expected.put(3, "ccc");
184 expected.put(4, "dddd");
185
186 mapped.subscribe(objectObserver);
187
188 verify(objectObserver, never()).onError(any(Throwable.class));
189 verify(objectObserver, times(1)).onNext(expected);
190 verify(objectObserver, times(1)).onComplete();
191 }
192
193 @Test
194 public void toMapWithErrorThrowingFactoryObservable() {
195 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
196
197 Supplier<Map<Integer, String>> mapFactory = new Supplier<Map<Integer, String>>() {
198 @Override
199 public Map<Integer, String> get() {
200 throw new RuntimeException("Forced failure");
201 }
202 };
203
204 Function<String, Integer> lengthFunc = new Function<String, Integer>() {
205 @Override
206 public Integer apply(String t1) {
207 return t1.length();
208 }
209 };
210 Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, new Function<String, String>() {
211 @Override
212 public String apply(String v) {
213 return v;
214 }
215 }, mapFactory).toObservable();
216
217 Map<Integer, String> expected = new LinkedHashMap<>();
218 expected.put(2, "bb");
219 expected.put(3, "ccc");
220 expected.put(4, "dddd");
221
222 mapped.subscribe(objectObserver);
223
224 verify(objectObserver, never()).onNext(expected);
225 verify(objectObserver, never()).onComplete();
226 verify(objectObserver, times(1)).onError(any(Throwable.class));
227 }
228
229 @Test
230 public void toMap() {
231 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
232
233 Single<Map<Integer, String>> mapped = source.toMap(lengthFunc);
234
235 Map<Integer, String> expected = new HashMap<>();
236 expected.put(1, "a");
237 expected.put(2, "bb");
238 expected.put(3, "ccc");
239 expected.put(4, "dddd");
240
241 mapped.subscribe(singleObserver);
242
243 verify(singleObserver, never()).onError(any(Throwable.class));
244 verify(singleObserver, times(1)).onSuccess(expected);
245 }
246
247 @Test
248 public void toMapWithValueSelector() {
249 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
250
251 Single<Map<Integer, String>> mapped = source.toMap(lengthFunc, duplicate);
252
253 Map<Integer, String> expected = new HashMap<>();
254 expected.put(1, "aa");
255 expected.put(2, "bbbb");
256 expected.put(3, "cccccc");
257 expected.put(4, "dddddddd");
258
259 mapped.subscribe(singleObserver);
260
261 verify(singleObserver, never()).onError(any(Throwable.class));
262 verify(singleObserver, times(1)).onSuccess(expected);
263 }
264
265 @Test
266 public void toMapWithError() {
267 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
268
269 Function<String, Integer> lengthFuncErr = new Function<String, Integer>() {
270 @Override
271 public Integer apply(String t1) {
272 if ("bb".equals(t1)) {
273 throw new RuntimeException("Forced Failure");
274 }
275 return t1.length();
276 }
277 };
278 Single<Map<Integer, String>> mapped = source.toMap(lengthFuncErr);
279
280 Map<Integer, String> expected = new HashMap<>();
281 expected.put(1, "a");
282 expected.put(2, "bb");
283 expected.put(3, "ccc");
284 expected.put(4, "dddd");
285
286 mapped.subscribe(singleObserver);
287
288 verify(singleObserver, never()).onSuccess(expected);
289 verify(singleObserver, times(1)).onError(any(Throwable.class));
290
291 }
292
293 @Test
294 public void toMapWithErrorInValueSelector() {
295 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
296
297 Function<String, String> duplicateErr = new Function<String, String>() {
298 @Override
299 public String apply(String t1) {
300 if ("bb".equals(t1)) {
301 throw new RuntimeException("Forced failure");
302 }
303 return t1 + t1;
304 }
305 };
306
307 Single<Map<Integer, String>> mapped = source.toMap(lengthFunc, duplicateErr);
308
309 Map<Integer, String> expected = new HashMap<>();
310 expected.put(1, "aa");
311 expected.put(2, "bbbb");
312 expected.put(3, "cccccc");
313 expected.put(4, "dddddddd");
314
315 mapped.subscribe(singleObserver);
316
317 verify(singleObserver, never()).onSuccess(expected);
318 verify(singleObserver, times(1)).onError(any(Throwable.class));
319
320 }
321
322 @Test
323 public void toMapWithFactory() {
324 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
325
326 Supplier<Map<Integer, String>> mapFactory = new Supplier<Map<Integer, String>>() {
327 @Override
328 public Map<Integer, String> get() {
329 return new LinkedHashMap<Integer, String>() {
330
331 private static final long serialVersionUID = -3296811238780863394L;
332
333 @Override
334 protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
335 return size() > 3;
336 }
337 };
338 }
339 };
340
341 Function<String, Integer> lengthFunc = new Function<String, Integer>() {
342 @Override
343 public Integer apply(String t1) {
344 return t1.length();
345 }
346 };
347 Single<Map<Integer, String>> mapped = source.toMap(lengthFunc, new Function<String, String>() {
348 @Override
349 public String apply(String v) {
350 return v;
351 }
352 }, mapFactory);
353
354 Map<Integer, String> expected = new LinkedHashMap<>();
355 expected.put(2, "bb");
356 expected.put(3, "ccc");
357 expected.put(4, "dddd");
358
359 mapped.subscribe(singleObserver);
360
361 verify(singleObserver, never()).onError(any(Throwable.class));
362 verify(singleObserver, times(1)).onSuccess(expected);
363 }
364
365 @Test
366 public void toMapWithErrorThrowingFactory() {
367 Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
368
369 Supplier<Map<Integer, String>> mapFactory = new Supplier<Map<Integer, String>>() {
370 @Override
371 public Map<Integer, String> get() {
372 throw new RuntimeException("Forced failure");
373 }
374 };
375
376 Function<String, Integer> lengthFunc = new Function<String, Integer>() {
377 @Override
378 public Integer apply(String t1) {
379 return t1.length();
380 }
381 };
382 Single<Map<Integer, String>> mapped = source.toMap(lengthFunc, new Function<String, String>() {
383 @Override
384 public String apply(String v) {
385 return v;
386 }
387 }, mapFactory);
388
389 Map<Integer, String> expected = new LinkedHashMap<>();
390 expected.put(2, "bb");
391 expected.put(3, "ccc");
392 expected.put(4, "dddd");
393
394 mapped.subscribe(singleObserver);
395
396 verify(singleObserver, never()).onSuccess(expected);
397 verify(singleObserver, times(1)).onError(any(Throwable.class));
398 }
399
400 }