Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/subscribers/DeferredScalarSubscriberTest.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 import java.util.concurrent.TimeUnit;
20 import java.util.concurrent.atomic.AtomicInteger;
21
22 import org.junit.Test;
23 import org.reactivestreams.*;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.core.Scheduler.Worker;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
29 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
30 import io.reactivex.rxjava3.processors.PublishProcessor;
31 import io.reactivex.rxjava3.schedulers.Schedulers;
32 import io.reactivex.rxjava3.subscribers.TestSubscriber;
33 import io.reactivex.rxjava3.testsupport.TestHelper;
34
35 public class DeferredScalarSubscriberTest extends RxJavaTest {
36
37 @Test
38 public void completeFirst() {
39 TestSubscriber<Integer> ts = TestSubscriber.create(0L);
40 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
41 ds.setupDownstream();
42
43 ds.onNext(1);
44
45 ts.assertNoValues();
46
47 ds.onComplete();
48
49 ts.assertNoValues();
50
51 ts.request(1);
52
53 ts.assertValues(1);
54 ts.assertNoErrors();
55 ts.assertComplete();
56 }
57
58 @Test
59 public void requestFirst() {
60 TestSubscriber<Integer> ts = TestSubscriber.create(1);
61 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
62 ds.setupDownstream();
63
64 ds.onNext(1);
65
66 ts.assertNoValues();
67
68 ds.onComplete();
69
70 ts.assertValues(1);
71 ts.assertNoErrors();
72 ts.assertComplete();
73 }
74
75 @Test
76 public void empty() {
77 TestSubscriber<Integer> ts = TestSubscriber.create(0L);
78 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
79 ds.setupDownstream();
80
81 ts.assertNoValues();
82
83 ds.onComplete();
84
85 ts.assertNoValues();
86 ts.assertNoErrors();
87 ts.assertComplete();
88 }
89
90 @Test
91 public void error() {
92 TestSubscriber<Integer> ts = TestSubscriber.create(0L);
93 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
94 ds.setupDownstream();
95
96 ts.assertNoValues();
97
98 ds.onError(new TestException());
99
100 ts.assertNoValues();
101 ts.assertError(TestException.class);
102 ts.assertNotComplete();
103 }
104
105 @Test
106 public void unsubscribeComposes() {
107 PublishProcessor<Integer> pp = PublishProcessor.create();
108 TestSubscriber<Integer> ts = TestSubscriber.create(0L);
109 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
110
111 pp.subscribe(ds);
112
113 assertTrue("No subscribers?", pp.hasSubscribers());
114
115 ts.cancel();
116
117 ds.onNext(1);
118 ds.onComplete();
119
120 ts.request(1);
121
122 ts.assertNoValues();
123 ts.assertNoErrors();
124 ts.assertNotComplete();
125
126 assertFalse("Subscribers?", pp.hasSubscribers());
127 assertTrue("Deferred not unsubscribed?", ds.isCancelled());
128 }
129
130 @Test
131 public void emptySource() {
132 TestSubscriber<Integer> ts = TestSubscriber.create(0L);
133 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
134 Flowable.just(1).ignoreElements().<Integer>toFlowable().subscribe(ds); // we need a producer from upstream
135
136 ts.assertNoValues();
137
138 ts.assertNoValues();
139 ts.assertNoErrors();
140 ts.assertComplete();
141 }
142
143 @Test
144 public void justSource() {
145 TestSubscriber<Integer> ts = TestSubscriber.create(0L);
146 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
147 ds.subscribeTo(Flowable.just(1));
148
149 ts.assertNoValues();
150
151 ts.request(1);
152
153 ts.assertValue(1);
154 ts.assertNoErrors();
155 ts.assertComplete();
156 }
157
158 @Test
159 public void rangeSource() {
160 TestSubscriber<Integer> ts = TestSubscriber.create(0);
161 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
162 ds.subscribeTo(Flowable.range(1, 10));
163
164 ts.assertNoValues();
165
166 ts.request(1);
167
168 ts.assertValue(10);
169 ts.assertNoErrors();
170 ts.assertComplete();
171 }
172
173 @Test
174 public void completeAfterNext() {
175 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
176 @Override
177 public void onNext(Integer t) {
178 super.onNext(t);
179 cancel();
180 }
181 };
182 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
183 ds.setupDownstream();
184 ds.onNext(1);
185
186 ts.assertNoValues();
187
188 ds.onComplete();
189
190 ts.assertValue(1);
191 ts.assertNoErrors();
192 ts.assertNotComplete();
193 }
194
195 @Test
196 public void completeAfterNextViaRequest() {
197 TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L) {
198 @Override
199 public void onNext(Integer t) {
200 super.onNext(t);
201 cancel();
202 }
203 };
204 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
205 ds.setupDownstream();
206 ds.onNext(1);
207 ds.onComplete();
208
209 ts.assertNoValues();
210
211 ts.request(1);
212
213 ts.assertValue(1);
214 ts.assertNoErrors();
215 ts.assertNotComplete();
216 }
217
218 @Test
219 public void doubleComplete() {
220 TestSubscriber<Integer> ts = TestSubscriber.create(0);
221 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
222 ds.setupDownstream();
223
224 ds.onNext(1);
225
226 ts.request(1);
227
228 ds.onComplete();
229 ds.onComplete();
230
231 ts.assertValue(1);
232 ts.assertNoErrors();
233 ts.assertComplete();
234 }
235
236 @Test
237 public void doubleComplete2() {
238 TestSubscriber<Integer> ts = TestSubscriber.create(0);
239 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
240 ds.setupDownstream();
241
242 ds.onNext(1);
243
244 ds.onComplete();
245 ds.onComplete();
246
247 ts.request(1);
248
249 ts.assertValue(1);
250 ts.assertNoErrors();
251 ts.assertComplete();
252 }
253
254 @Test
255 public void doubleRequest() {
256 TestSubscriber<Integer> ts = TestSubscriber.create(0);
257 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
258 ds.setupDownstream();
259
260 ds.onNext(1);
261
262 ts.request(1);
263 ts.request(1);
264
265 ds.onComplete();
266
267 ts.assertValue(1);
268 ts.assertNoErrors();
269 ts.assertComplete();
270 }
271
272 @Test
273 public void negativeRequest() {
274 List<Throwable> list = TestHelper.trackPluginErrors();
275
276 TestSubscriber<Integer> ts = TestSubscriber.create(0);
277 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
278 ds.setupDownstream();
279
280 ds.downstreamRequest(-99);
281
282 RxJavaPlugins.reset();
283 TestHelper.assertError(list, 0, IllegalArgumentException.class, "n > 0 required but it was -99");
284 }
285
286 @Test
287 public void callsAfterUnsubscribe() {
288 TestSubscriber<Integer> ts = TestSubscriber.create(0);
289 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
290 ds.setupDownstream();
291
292 ts.cancel();
293
294 ds.downstreamRequest(1);
295 ds.onNext(1);
296 ds.onComplete();
297 ds.onComplete();
298
299 ts.assertNoValues();
300 ts.assertNoErrors();
301 ts.assertNotComplete();
302 }
303
304 @Test
305 public void emissionRequestRace() {
306 Worker w = Schedulers.computation().createWorker();
307 try {
308 for (int i = 0; i < 10000; i++) {
309
310 final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
311 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
312 ds.setupDownstream();
313 ds.onNext(1);
314
315 final AtomicInteger ready = new AtomicInteger(2);
316
317 w.schedule(new Runnable() {
318 @Override
319 public void run() {
320 ready.decrementAndGet();
321 while (ready.get() != 0) { }
322
323 ts.request(1);
324 }
325 });
326
327 ready.decrementAndGet();
328 while (ready.get() != 0) { }
329
330 ds.onComplete();
331
332 ts.awaitDone(5, TimeUnit.SECONDS);
333 ts.assertValues(1);
334 ts.assertNoErrors();
335 ts.assertComplete();
336
337 }
338 } finally {
339 w.dispose();
340 }
341 }
342
343 @Test
344 public void emissionRequestRace2() {
345 Worker w = Schedulers.io().createWorker();
346 Worker w2 = Schedulers.io().createWorker();
347 int m = 10000;
348 if (Runtime.getRuntime().availableProcessors() < 3) {
349 m = 1000;
350 }
351 try {
352 for (int i = 0; i < m; i++) {
353
354 final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
355 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
356 ds.setupDownstream();
357 ds.onNext(1);
358
359 final AtomicInteger ready = new AtomicInteger(3);
360
361 w.schedule(new Runnable() {
362 @Override
363 public void run() {
364 ready.decrementAndGet();
365 while (ready.get() != 0) { }
366
367 ts.request(1);
368 }
369 });
370
371 w2.schedule(new Runnable() {
372 @Override
373 public void run() {
374 ready.decrementAndGet();
375 while (ready.get() != 0) { }
376
377 ts.request(1);
378 }
379 });
380
381 ready.decrementAndGet();
382 while (ready.get() != 0) { }
383
384 ds.onComplete();
385
386 ts.awaitDone(5, TimeUnit.SECONDS);
387 ts.assertValues(1);
388 ts.assertNoErrors();
389 ts.assertComplete();
390
391 }
392 } finally {
393 w.dispose();
394 w2.dispose();
395 }
396 }
397
398 static final class TestingDeferredScalarSubscriber extends DeferredScalarSubscriber<Integer, Integer> {
399
400 private static final long serialVersionUID = 6285096158319517837L;
401
402 TestingDeferredScalarSubscriber(Subscriber<? super Integer> downstream) {
403 super(downstream);
404 }
405
406 @Override
407 public void onNext(Integer t) {
408 value = t;
409 hasValue = true;
410 }
411
412 public void setupDownstream() {
413 onSubscribe(new BooleanSubscription());
414 }
415
416 public void subscribeTo(Publisher<Integer> p) {
417 p.subscribe(this);
418 }
419
420 public void downstreamRequest(long n) {
421 request(n);
422 }
423 }
424
425 @Test
426 public void doubleOnSubscribe() {
427 TestHelper.doubleOnSubscribe(new DeferredScalarSubscriber<Integer, Integer>(new TestSubscriber<>()) {
428 private static final long serialVersionUID = -4445381578878059054L;
429
430 @Override
431 public void onNext(Integer t) {
432 }
433 });
434 }
435 }