Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableDoAfterNextTest.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.junit.Assert.*;
17
18 import java.util.*;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.core.Observable;
23 import io.reactivex.rxjava3.core.RxJavaTest;
24 import io.reactivex.rxjava3.exceptions.TestException;
25 import io.reactivex.rxjava3.functions.Consumer;
26 import io.reactivex.rxjava3.internal.functions.Functions;
27 import io.reactivex.rxjava3.observers.TestObserver;
28 import io.reactivex.rxjava3.operators.QueueFuseable;
29 import io.reactivex.rxjava3.subjects.UnicastSubject;
30 import io.reactivex.rxjava3.testsupport.*;
31
32 public class ObservableDoAfterNextTest extends RxJavaTest {
33
34 final List<Integer> values = new ArrayList<>();
35
36 final Consumer<Integer> afterNext = new Consumer<Integer>() {
37 @Override
38 public void accept(Integer e) throws Exception {
39 values.add(-e);
40 }
41 };
42
43 final TestObserver<Integer> to = new TestObserver<Integer>() {
44 @Override
45 public void onNext(Integer t) {
46 super.onNext(t);
47 ObservableDoAfterNextTest.this.values.add(t);
48 }
49 };
50
51 @Test
52 public void just() {
53 Observable.just(1)
54 .doAfterNext(afterNext)
55 .subscribeWith(to)
56 .assertResult(1);
57
58 assertEquals(Arrays.asList(1, -1), values);
59 }
60
61 @Test
62 public void justHidden() {
63 Observable.just(1)
64 .hide()
65 .doAfterNext(afterNext)
66 .subscribeWith(to)
67 .assertResult(1);
68
69 assertEquals(Arrays.asList(1, -1), values);
70 }
71
72 @Test
73 public void range() {
74 Observable.range(1, 5)
75 .doAfterNext(afterNext)
76 .subscribeWith(to)
77 .assertResult(1, 2, 3, 4, 5);
78
79 assertEquals(Arrays.asList(1, -1, 2, -2, 3, -3, 4, -4, 5, -5), values);
80 }
81
82 @Test
83 public void error() {
84 Observable.<Integer>error(new TestException())
85 .doAfterNext(afterNext)
86 .subscribeWith(to)
87 .assertFailure(TestException.class);
88
89 assertTrue(values.isEmpty());
90 }
91
92 @Test
93 public void empty() {
94 Observable.<Integer>empty()
95 .doAfterNext(afterNext)
96 .subscribeWith(to)
97 .assertResult();
98
99 assertTrue(values.isEmpty());
100 }
101
102 @Test
103 public void syncFused() {
104 TestObserverEx<Integer> to0 = new TestObserverEx<>(QueueFuseable.SYNC);
105
106 Observable.range(1, 5)
107 .doAfterNext(afterNext)
108 .subscribe(to0);
109
110 to0.assertFusionMode(QueueFuseable.SYNC)
111 .assertResult(1, 2, 3, 4, 5);
112
113 assertEquals(Arrays.asList(-1, -2, -3, -4, -5), values);
114 }
115
116 @Test
117 public void asyncFusedRejected() {
118 TestObserverEx<Integer> to0 = new TestObserverEx<>(QueueFuseable.ASYNC);
119
120 Observable.range(1, 5)
121 .doAfterNext(afterNext)
122 .subscribe(to0);
123
124 to0.assertFusionMode(QueueFuseable.NONE)
125 .assertResult(1, 2, 3, 4, 5);
126
127 assertEquals(Arrays.asList(-1, -2, -3, -4, -5), values);
128 }
129
130 @Test
131 public void asyncFused() {
132 TestObserverEx<Integer> to0 = new TestObserverEx<>(QueueFuseable.ASYNC);
133
134 UnicastSubject<Integer> us = UnicastSubject.create();
135
136 TestHelper.emit(us, 1, 2, 3, 4, 5);
137
138 us
139 .doAfterNext(afterNext)
140 .subscribe(to0);
141
142 to0.assertFusionMode(QueueFuseable.ASYNC)
143 .assertResult(1, 2, 3, 4, 5);
144
145 assertEquals(Arrays.asList(-1, -2, -3, -4, -5), values);
146 }
147
148 @Test
149 public void justConditional() {
150 Observable.just(1)
151 .doAfterNext(afterNext)
152 .filter(Functions.alwaysTrue())
153 .subscribeWith(to)
154 .assertResult(1);
155
156 assertEquals(Arrays.asList(1, -1), values);
157 }
158
159 @Test
160 public void rangeConditional() {
161 Observable.range(1, 5)
162 .doAfterNext(afterNext)
163 .filter(Functions.alwaysTrue())
164 .subscribeWith(to)
165 .assertResult(1, 2, 3, 4, 5);
166
167 assertEquals(Arrays.asList(1, -1, 2, -2, 3, -3, 4, -4, 5, -5), values);
168 }
169
170 @Test
171 public void errorConditional() {
172 Observable.<Integer>error(new TestException())
173 .doAfterNext(afterNext)
174 .filter(Functions.alwaysTrue())
175 .subscribeWith(to)
176 .assertFailure(TestException.class);
177
178 assertTrue(values.isEmpty());
179 }
180
181 @Test
182 public void emptyConditional() {
183 Observable.<Integer>empty()
184 .doAfterNext(afterNext)
185 .filter(Functions.alwaysTrue())
186 .subscribeWith(to)
187 .assertResult();
188
189 assertTrue(values.isEmpty());
190 }
191
192 @Test
193 public void syncFusedConditional() {
194 TestObserverEx<Integer> to0 = new TestObserverEx<>(QueueFuseable.SYNC);
195
196 Observable.range(1, 5)
197 .doAfterNext(afterNext)
198 .filter(Functions.alwaysTrue())
199 .subscribe(to0);
200
201 to0.assertFusionMode(QueueFuseable.SYNC)
202 .assertResult(1, 2, 3, 4, 5);
203
204 assertEquals(Arrays.asList(-1, -2, -3, -4, -5), values);
205 }
206
207 @Test
208 public void asyncFusedRejectedConditional() {
209 TestObserverEx<Integer> to0 = new TestObserverEx<>(QueueFuseable.ASYNC);
210
211 Observable.range(1, 5)
212 .doAfterNext(afterNext)
213 .filter(Functions.alwaysTrue())
214 .subscribe(to0);
215
216 to0.assertFusionMode(QueueFuseable.NONE)
217 .assertResult(1, 2, 3, 4, 5);
218
219 assertEquals(Arrays.asList(-1, -2, -3, -4, -5), values);
220 }
221
222 @Test
223 public void asyncFusedConditional() {
224 TestObserverEx<Integer> to0 = new TestObserverEx<>(QueueFuseable.ASYNC);
225
226 UnicastSubject<Integer> us = UnicastSubject.create();
227
228 TestHelper.emit(us, 1, 2, 3, 4, 5);
229
230 us
231 .doAfterNext(afterNext)
232 .filter(Functions.alwaysTrue())
233 .subscribe(to0);
234
235 to0.assertFusionMode(QueueFuseable.ASYNC)
236 .assertResult(1, 2, 3, 4, 5);
237
238 assertEquals(Arrays.asList(-1, -2, -3, -4, -5), values);
239 }
240
241 @Test
242 public void consumerThrows() {
243 Observable.just(1, 2)
244 .doAfterNext(new Consumer<Integer>() {
245 @Override
246 public void accept(Integer e) throws Exception {
247 throw new TestException();
248 }
249 })
250 .test()
251 .assertFailure(TestException.class, 1);
252 }
253
254 @Test
255 public void consumerThrowsConditional() {
256 Observable.just(1, 2)
257 .doAfterNext(new Consumer<Integer>() {
258 @Override
259 public void accept(Integer e) throws Exception {
260 throw new TestException();
261 }
262 })
263 .filter(Functions.alwaysTrue())
264 .test()
265 .assertFailure(TestException.class, 1);
266 }
267
268 @Test
269 public void consumerThrowsConditional2() {
270 Observable.just(1, 2).hide()
271 .doAfterNext(new Consumer<Integer>() {
272 @Override
273 public void accept(Integer e) throws Exception {
274 throw new TestException();
275 }
276 })
277 .filter(Functions.alwaysTrue())
278 .test()
279 .assertFailure(TestException.class, 1);
280 }
281 }