Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/subscribers/QueueDrainSubscriberTest.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.subscribers;
15
16 import static org.junit.Assert.*;
17
18 import java.util.List;
19
20 import org.junit.Test;
21 import org.reactivestreams.*;
22
23 import io.reactivex.rxjava3.core.RxJavaTest;
24 import io.reactivex.rxjava3.disposables.*;
25 import io.reactivex.rxjava3.exceptions.MissingBackpressureException;
26 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
27 import io.reactivex.rxjava3.operators.SpscArrayQueue;
28 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
29 import io.reactivex.rxjava3.subscribers.TestSubscriber;
30 import io.reactivex.rxjava3.testsupport.TestHelper;
31
32 public class QueueDrainSubscriberTest extends RxJavaTest {
33
34 static final QueueDrainSubscriber<Integer, Integer, Integer> createUnordered(TestSubscriber<Integer> ts, final Disposable d) {
35 return new QueueDrainSubscriber<Integer, Integer, Integer>(ts, new SpscArrayQueue<>(4)) {
36 @Override
37 public void onNext(Integer t) {
38 fastPathEmitMax(t, false, d);
39 }
40
41 @Override
42 public void onError(Throwable t) {
43 }
44
45 @Override
46 public void onComplete() {
47 }
48
49 @Override
50 public void onSubscribe(Subscription s) {
51 }
52
53 @Override
54 public boolean accept(Subscriber<? super Integer> a, Integer v) {
55 super.accept(a, v);
56 a.onNext(v);
57 return true;
58 }
59 };
60 }
61
62 static final QueueDrainSubscriber<Integer, Integer, Integer> createOrdered(TestSubscriber<Integer> ts, final Disposable d) {
63 return new QueueDrainSubscriber<Integer, Integer, Integer>(ts, new SpscArrayQueue<>(4)) {
64 @Override
65 public void onNext(Integer t) {
66 fastPathOrderedEmitMax(t, false, d);
67 }
68
69 @Override
70 public void onError(Throwable t) {
71 }
72
73 @Override
74 public void onComplete() {
75 }
76
77 @Override
78 public void onSubscribe(Subscription s) {
79 }
80
81 @Override
82 public boolean accept(Subscriber<? super Integer> a, Integer v) {
83 super.accept(a, v);
84 a.onNext(v);
85 return true;
86 }
87 };
88 }
89
90 static final QueueDrainSubscriber<Integer, Integer, Integer> createUnorderedReject(TestSubscriber<Integer> ts, final Disposable d) {
91 return new QueueDrainSubscriber<Integer, Integer, Integer>(ts, new SpscArrayQueue<>(4)) {
92 @Override
93 public void onNext(Integer t) {
94 fastPathEmitMax(t, false, d);
95 }
96
97 @Override
98 public void onError(Throwable t) {
99 }
100
101 @Override
102 public void onComplete() {
103 }
104
105 @Override
106 public void onSubscribe(Subscription s) {
107 }
108
109 @Override
110 public boolean accept(Subscriber<? super Integer> a, Integer v) {
111 super.accept(a, v);
112 a.onNext(v);
113 return false;
114 }
115 };
116 }
117
118 static final QueueDrainSubscriber<Integer, Integer, Integer> createOrderedReject(TestSubscriber<Integer> ts, final Disposable d) {
119 return new QueueDrainSubscriber<Integer, Integer, Integer>(ts, new SpscArrayQueue<>(4)) {
120 @Override
121 public void onNext(Integer t) {
122 fastPathOrderedEmitMax(t, false, d);
123 }
124
125 @Override
126 public void onError(Throwable t) {
127 }
128
129 @Override
130 public void onComplete() {
131 }
132
133 @Override
134 public void onSubscribe(Subscription s) {
135 }
136
137 @Override
138 public boolean accept(Subscriber<? super Integer> a, Integer v) {
139 super.accept(a, v);
140 a.onNext(v);
141 return false;
142 }
143 };
144 }
145
146 @Test
147 public void unorderedFastPathNoRequest() {
148 TestSubscriber<Integer> ts = new TestSubscriber<>(0);
149 Disposable d = Disposable.empty();
150 QueueDrainSubscriber<Integer, Integer, Integer> qd = createUnordered(ts, d);
151 ts.onSubscribe(new BooleanSubscription());
152
153 qd.onNext(1);
154
155 ts.assertFailure(MissingBackpressureException.class);
156
157 assertTrue(d.isDisposed());
158 }
159
160 @Test
161 public void orderedFastPathNoRequest() {
162 TestSubscriber<Integer> ts = new TestSubscriber<>(0);
163 Disposable d = Disposable.empty();
164 QueueDrainSubscriber<Integer, Integer, Integer> qd = createOrdered(ts, d);
165 ts.onSubscribe(new BooleanSubscription());
166
167 qd.onNext(1);
168
169 ts.assertFailure(MissingBackpressureException.class);
170
171 assertTrue(d.isDisposed());
172 }
173
174 @Test
175 public void acceptBadRequest() {
176 TestSubscriber<Integer> ts = new TestSubscriber<>(0);
177 Disposable d = Disposable.empty();
178 QueueDrainSubscriber<Integer, Integer, Integer> qd = createUnordered(ts, d);
179 ts.onSubscribe(new BooleanSubscription());
180
181 assertTrue(qd.accept(ts, 0));
182
183 List<Throwable> errors = TestHelper.trackPluginErrors();
184 try {
185 qd.requested(-1);
186 TestHelper.assertError(errors, 0, IllegalArgumentException.class);
187 } finally {
188 RxJavaPlugins.reset();
189 }
190 }
191
192 @Test
193 public void unorderedFastPathRequest1() {
194 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
195 Disposable d = Disposable.empty();
196 QueueDrainSubscriber<Integer, Integer, Integer> qd = createUnordered(ts, d);
197 ts.onSubscribe(new BooleanSubscription());
198
199 qd.requested(1);
200
201 qd.onNext(1);
202
203 ts.assertValuesOnly(1);
204 }
205
206 @Test
207 public void orderedFastPathRequest1() {
208 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
209 Disposable d = Disposable.empty();
210 QueueDrainSubscriber<Integer, Integer, Integer> qd = createOrdered(ts, d);
211 ts.onSubscribe(new BooleanSubscription());
212
213 qd.requested(1);
214
215 qd.onNext(1);
216
217 ts.assertValuesOnly(1);
218 }
219
220 @Test
221 public void unorderedSlowPath() {
222 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
223 Disposable d = Disposable.empty();
224 QueueDrainSubscriber<Integer, Integer, Integer> qd = createUnordered(ts, d);
225 ts.onSubscribe(new BooleanSubscription());
226
227 qd.enter();
228 qd.onNext(1);
229
230 ts.assertEmpty();
231 }
232
233 @Test
234 public void orderedSlowPath() {
235 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
236 Disposable d = Disposable.empty();
237 QueueDrainSubscriber<Integer, Integer, Integer> qd = createOrdered(ts, d);
238 ts.onSubscribe(new BooleanSubscription());
239
240 qd.enter();
241 qd.onNext(1);
242
243 ts.assertEmpty();
244 }
245
246 @Test
247 public void orderedSlowPathNonEmptyQueue() {
248 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
249 Disposable d = Disposable.empty();
250 QueueDrainSubscriber<Integer, Integer, Integer> qd = createOrdered(ts, d);
251 ts.onSubscribe(new BooleanSubscription());
252
253 qd.queue.offer(0);
254 qd.requested(2);
255 qd.onNext(1);
256
257 ts.assertValuesOnly(0, 1);
258 }
259
260 @Test
261 public void unorderedOnNextRace() {
262 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
263
264 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
265 Disposable d = Disposable.empty();
266 final QueueDrainSubscriber<Integer, Integer, Integer> qd = createUnordered(ts, d);
267 ts.onSubscribe(new BooleanSubscription());
268
269 qd.requested(Long.MAX_VALUE);
270 Runnable r1 = new Runnable() {
271 @Override
272 public void run() {
273 qd.onNext(1);
274 }
275 };
276
277 TestHelper.race(r1, r1);
278
279 ts.assertValuesOnly(1, 1);
280 }
281 }
282
283 @Test
284 public void orderedOnNextRace() {
285 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
286
287 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
288 Disposable d = Disposable.empty();
289 final QueueDrainSubscriber<Integer, Integer, Integer> qd = createOrdered(ts, d);
290 ts.onSubscribe(new BooleanSubscription());
291
292 qd.requested(Long.MAX_VALUE);
293 Runnable r1 = new Runnable() {
294 @Override
295 public void run() {
296 qd.onNext(1);
297 }
298 };
299
300 TestHelper.race(r1, r1);
301
302 ts.assertValuesOnly(1, 1);
303 }
304 }
305
306 @Test
307 public void unorderedFastPathReject() {
308 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
309 Disposable d = Disposable.empty();
310 QueueDrainSubscriber<Integer, Integer, Integer> qd = createUnorderedReject(ts, d);
311 ts.onSubscribe(new BooleanSubscription());
312
313 qd.requested(1);
314
315 qd.onNext(1);
316
317 ts.assertValuesOnly(1);
318
319 assertEquals(1, qd.requested());
320 }
321
322 @Test
323 public void orderedFastPathReject() {
324 TestSubscriber<Integer> ts = new TestSubscriber<>(1);
325 Disposable d = Disposable.empty();
326 QueueDrainSubscriber<Integer, Integer, Integer> qd = createOrderedReject(ts, d);
327 ts.onSubscribe(new BooleanSubscription());
328
329 qd.requested(1);
330
331 qd.onNext(1);
332
333 ts.assertValuesOnly(1);
334
335 assertEquals(1, qd.requested());
336 }
337 }