Debian Codegraph @

src/test/java/io/reactivex/rxjava3/subjects/PublishSubjectTest.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.subjects;
15
16 import static org.junit.Assert.*;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.ArrayList;
21 import java.util.concurrent.TimeUnit;
22 import java.util.concurrent.atomic.AtomicInteger;
23
24 import org.junit.Test;
25 import org.mockito.*;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.disposables.Disposable;
29 import io.reactivex.rxjava3.exceptions.TestException;
30 import io.reactivex.rxjava3.functions.*;
31 import io.reactivex.rxjava3.observers.*;
32 import io.reactivex.rxjava3.testsupport.*;
33
34 public class PublishSubjectTest extends SubjectTest<Integer> {
35
36 @Override
37 protected Subject<Integer> create() {
38 return PublishSubject.create();
39 }
40
41 @Test
42 @SuppressUndeliverable
43 public void completed() {
44 PublishSubject<String> subject = PublishSubject.create();
45
46 Observer<String> observer = TestHelper.mockObserver();
47 subject.subscribe(observer);
48
49 subject.onNext("one");
50 subject.onNext("two");
51 subject.onNext("three");
52 subject.onComplete();
53
54 Observer<String> anotherSubscriber = TestHelper.mockObserver();
55 subject.subscribe(anotherSubscriber);
56
57 subject.onNext("four");
58 subject.onComplete();
59 subject.onError(new Throwable());
60
61 assertCompletedSubscriber(observer);
62 // todo bug? assertNeverSubscriber(anotherSubscriber);
63 }
64
65 @Test
66 public void completedStopsEmittingData() {
67 PublishSubject<Object> channel = PublishSubject.create();
68 Observer<Object> observerA = TestHelper.mockObserver();
69 Observer<Object> observerB = TestHelper.mockObserver();
70 Observer<Object> observerC = TestHelper.mockObserver();
71
72 TestObserver<Object> to = new TestObserver<>(observerA);
73
74 channel.subscribe(to);
75 channel.subscribe(observerB);
76
77 InOrder inOrderA = inOrder(observerA);
78 InOrder inOrderB = inOrder(observerB);
79 InOrder inOrderC = inOrder(observerC);
80
81 channel.onNext(42);
82
83 inOrderA.verify(observerA).onNext(42);
84 inOrderB.verify(observerB).onNext(42);
85
86 to.dispose();
87 inOrderA.verifyNoMoreInteractions();
88
89 channel.onNext(4711);
90
91 inOrderB.verify(observerB).onNext(4711);
92
93 channel.onComplete();
94
95 inOrderB.verify(observerB).onComplete();
96
97 channel.subscribe(observerC);
98
99 inOrderC.verify(observerC).onComplete();
100
101 channel.onNext(13);
102
103 inOrderB.verifyNoMoreInteractions();
104 inOrderC.verifyNoMoreInteractions();
105 }
106
107 private void assertCompletedSubscriber(Observer<String> observer) {
108 verify(observer, times(1)).onNext("one");
109 verify(observer, times(1)).onNext("two");
110 verify(observer, times(1)).onNext("three");
111 verify(observer, Mockito.never()).onError(any(Throwable.class));
112 verify(observer, times(1)).onComplete();
113 }
114
115 @Test
116 @SuppressUndeliverable
117 public void error() {
118 PublishSubject<String> subject = PublishSubject.create();
119
120 Observer<String> observer = TestHelper.mockObserver();
121 subject.subscribe(observer);
122
123 subject.onNext("one");
124 subject.onNext("two");
125 subject.onNext("three");
126 subject.onError(testException);
127
128 Observer<String> anotherSubscriber = TestHelper.mockObserver();
129 subject.subscribe(anotherSubscriber);
130
131 subject.onNext("four");
132 subject.onError(new Throwable());
133 subject.onComplete();
134
135 assertErrorSubscriber(observer);
136 // todo bug? assertNeverSubscriber(anotherSubscriber);
137 }
138
139 private void assertErrorSubscriber(Observer<String> observer) {
140 verify(observer, times(1)).onNext("one");
141 verify(observer, times(1)).onNext("two");
142 verify(observer, times(1)).onNext("three");
143 verify(observer, times(1)).onError(testException);
144 verify(observer, Mockito.never()).onComplete();
145 }
146
147 @Test
148 public void subscribeMidSequence() {
149 PublishSubject<String> subject = PublishSubject.create();
150
151 Observer<String> observer = TestHelper.mockObserver();
152 subject.subscribe(observer);
153
154 subject.onNext("one");
155 subject.onNext("two");
156
157 assertObservedUntilTwo(observer);
158
159 Observer<String> anotherSubscriber = TestHelper.mockObserver();
160 subject.subscribe(anotherSubscriber);
161
162 subject.onNext("three");
163 subject.onComplete();
164
165 assertCompletedSubscriber(observer);
166 assertCompletedStartingWithThreeSubscriber(anotherSubscriber);
167 }
168
169 private void assertCompletedStartingWithThreeSubscriber(Observer<String> observer) {
170 verify(observer, Mockito.never()).onNext("one");
171 verify(observer, Mockito.never()).onNext("two");
172 verify(observer, times(1)).onNext("three");
173 verify(observer, Mockito.never()).onError(any(Throwable.class));
174 verify(observer, times(1)).onComplete();
175 }
176
177 @Test
178 public void unsubscribeFirstSubscriber() {
179 PublishSubject<String> subject = PublishSubject.create();
180
181 Observer<String> observer = TestHelper.mockObserver();
182 TestObserver<String> to = new TestObserver<>(observer);
183 subject.subscribe(to);
184
185 subject.onNext("one");
186 subject.onNext("two");
187
188 to.dispose();
189 assertObservedUntilTwo(observer);
190
191 Observer<String> anotherSubscriber = TestHelper.mockObserver();
192 subject.subscribe(anotherSubscriber);
193
194 subject.onNext("three");
195 subject.onComplete();
196
197 assertObservedUntilTwo(observer);
198 assertCompletedStartingWithThreeSubscriber(anotherSubscriber);
199 }
200
201 private void assertObservedUntilTwo(Observer<String> observer) {
202 verify(observer, times(1)).onNext("one");
203 verify(observer, times(1)).onNext("two");
204 verify(observer, Mockito.never()).onNext("three");
205 verify(observer, Mockito.never()).onError(any(Throwable.class));
206 verify(observer, Mockito.never()).onComplete();
207 }
208
209 @Test
210 public void nestedSubscribe() {
211 final PublishSubject<Integer> s = PublishSubject.create();
212
213 final AtomicInteger countParent = new AtomicInteger();
214 final AtomicInteger countChildren = new AtomicInteger();
215 final AtomicInteger countTotal = new AtomicInteger();
216
217 final ArrayList<String> list = new ArrayList<>();
218
219 s.flatMap(new Function<Integer, Observable<String>>() {
220
221 @Override
222 public Observable<String> apply(final Integer v) {
223 countParent.incrementAndGet();
224
225 // then subscribe to subject again (it will not receive the previous value)
226 return s.map(new Function<Integer, String>() {
227
228 @Override
229 public String apply(Integer v2) {
230 countChildren.incrementAndGet();
231 return "Parent: " + v + " Child: " + v2;
232 }
233
234 });
235 }
236
237 }).subscribe(new Consumer<String>() {
238
239 @Override
240 public void accept(String v) {
241 countTotal.incrementAndGet();
242 list.add(v);
243 }
244
245 });
246
247 for (int i = 0; i < 10; i++) {
248 s.onNext(i);
249 }
250 s.onComplete();
251
252 // System.out.println("countParent: " + countParent.get());
253 // System.out.println("countChildren: " + countChildren.get());
254 // System.out.println("countTotal: " + countTotal.get());
255
256 // 9+8+7+6+5+4+3+2+1+0 == 45
257 assertEquals(45, list.size());
258 }
259
260 /**
261 * Should be able to unsubscribe all Subscribers, have it stop emitting, then subscribe new ones and it start emitting again.
262 */
263 @Test
264 public void reSubscribe() {
265 final PublishSubject<Integer> ps = PublishSubject.create();
266
267 Observer<Integer> o1 = TestHelper.mockObserver();
268 TestObserver<Integer> to = new TestObserver<>(o1);
269 ps.subscribe(to);
270
271 // emit
272 ps.onNext(1);
273
274 // validate we got it
275 InOrder inOrder1 = inOrder(o1);
276 inOrder1.verify(o1, times(1)).onNext(1);
277 inOrder1.verifyNoMoreInteractions();
278
279 // unsubscribe
280 to.dispose();
281
282 // emit again but nothing will be there to receive it
283 ps.onNext(2);
284
285 Observer<Integer> o2 = TestHelper.mockObserver();
286 TestObserver<Integer> to2 = new TestObserver<>(o2);
287 ps.subscribe(to2);
288
289 // emit
290 ps.onNext(3);
291
292 // validate we got it
293 InOrder inOrder2 = inOrder(o2);
294 inOrder2.verify(o2, times(1)).onNext(3);
295 inOrder2.verifyNoMoreInteractions();
296
297 to2.dispose();
298 }
299
300 private final Throwable testException = new Throwable();
301
302 @Test
303 public void unsubscriptionCase() {
304 PublishSubject<String> src = PublishSubject.create();
305
306 for (int i = 0; i < 10; i++) {
307 final Observer<Object> o = TestHelper.mockObserver();
308 InOrder inOrder = inOrder(o);
309 String v = "" + i;
310 System.out.printf("Turn: %d%n", i);
311 src.firstElement()
312 .toObservable()
313 .flatMap(new Function<String, Observable<String>>() {
314
315 @Override
316 public Observable<String> apply(String t1) {
317 return Observable.just(t1 + ", " + t1);
318 }
319 })
320 .subscribe(new DefaultObserver<String>() {
321 @Override
322 public void onNext(String t) {
323 o.onNext(t);
324 }
325
326 @Override
327 public void onError(Throwable e) {
328 o.onError(e);
329 }
330
331 @Override
332 public void onComplete() {
333 o.onComplete();
334 }
335 });
336 src.onNext(v);
337
338 inOrder.verify(o).onNext(v + ", " + v);
339 inOrder.verify(o).onComplete();
340 verify(o, never()).onError(any(Throwable.class));
341 }
342 }
343
344 @Test
345 public void currentStateMethodsNormal() {
346 PublishSubject<Object> as = PublishSubject.create();
347
348 assertFalse(as.hasThrowable());
349 assertFalse(as.hasComplete());
350 assertNull(as.getThrowable());
351
352 as.onNext(1);
353
354 assertFalse(as.hasThrowable());
355 assertFalse(as.hasComplete());
356 assertNull(as.getThrowable());
357
358 as.onComplete();
359
360 assertFalse(as.hasThrowable());
361 assertTrue(as.hasComplete());
362 assertNull(as.getThrowable());
363 }
364
365 @Test
366 public void currentStateMethodsEmpty() {
367 PublishSubject<Object> as = PublishSubject.create();
368
369 assertFalse(as.hasThrowable());
370 assertFalse(as.hasComplete());
371 assertNull(as.getThrowable());
372
373 as.onComplete();
374
375 assertFalse(as.hasThrowable());
376 assertTrue(as.hasComplete());
377 assertNull(as.getThrowable());
378 }
379
380 @Test
381 public void currentStateMethodsError() {
382 PublishSubject<Object> as = PublishSubject.create();
383
384 assertFalse(as.hasThrowable());
385 assertFalse(as.hasComplete());
386 assertNull(as.getThrowable());
387
388 as.onError(new TestException());
389
390 assertTrue(as.hasThrowable());
391 assertFalse(as.hasComplete());
392 assertTrue(as.getThrowable() instanceof TestException);
393 }
394
395 @Test
396 public void crossCancel() {
397 final TestObserver<Integer> to1 = new TestObserver<>();
398 TestObserver<Integer> to2 = new TestObserver<Integer>() {
399 @Override
400 public void onNext(Integer t) {
401 super.onNext(t);
402 to1.dispose();
403 }
404 };
405
406 PublishSubject<Integer> ps = PublishSubject.create();
407
408 ps.subscribe(to2);
409 ps.subscribe(to1);
410
411 ps.onNext(1);
412
413 to2.assertValue(1);
414
415 to1.assertNoValues();
416 }
417
418 @Test
419 @SuppressUndeliverable
420 public void crossCancelOnError() {
421 final TestObserver<Integer> to1 = new TestObserver<>();
422 TestObserver<Integer> to2 = new TestObserver<Integer>() {
423 @Override
424 public void onError(Throwable t) {
425 super.onError(t);
426 to1.dispose();
427 }
428 };
429
430 PublishSubject<Integer> ps = PublishSubject.create();
431
432 ps.subscribe(to2);
433 ps.subscribe(to1);
434
435 ps.onError(new TestException());
436
437 to2.assertError(TestException.class);
438
439 to1.assertNoErrors();
440 }
441
442 @Test
443 public void crossCancelOnComplete() {
444 final TestObserver<Integer> to1 = new TestObserver<>();
445 TestObserver<Integer> to2 = new TestObserver<Integer>() {
446 @Override
447 public void onComplete() {
448 super.onComplete();
449 to1.dispose();
450 }
451 };
452
453 PublishSubject<Integer> ps = PublishSubject.create();
454
455 ps.subscribe(to2);
456 ps.subscribe(to1);
457
458 ps.onComplete();
459
460 to2.assertComplete();
461
462 to1.assertNotComplete();
463 }
464
465 @Test
466 public void onSubscribeCancelsImmediately() {
467 PublishSubject<Integer> ps = PublishSubject.create();
468
469 TestObserver<Integer> to = ps.test();
470
471 ps.subscribe(new Observer<Integer>() {
472
473 @Override
474 public void onSubscribe(Disposable d) {
475 d.dispose();
476 d.dispose();
477 }
478
479 @Override
480 public void onNext(Integer t) {
481
482 }
483
484 @Override
485 public void onError(Throwable t) {
486
487 }
488
489 @Override
490 public void onComplete() {
491
492 }
493
494 });
495
496 to.dispose();
497
498 assertFalse(ps.hasObservers());
499 }
500
501 @Test
502 public void terminateRace() throws Exception {
503
504 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
505 final PublishSubject<Integer> ps = PublishSubject.create();
506
507 TestObserver<Integer> to = ps.test();
508
509 Runnable task = new Runnable() {
510 @Override
511 public void run() {
512 ps.onComplete();
513 }
514 };
515
516 TestHelper.race(task, task);
517
518 to
519 .awaitDone(5, TimeUnit.SECONDS)
520 .assertResult();
521 }
522 }
523
524 @Test
525 public void addRemoveRance() throws Exception {
526
527 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
528 final PublishSubject<Integer> ps = PublishSubject.create();
529
530 final TestObserver<Integer> to = ps.test();
531
532 Runnable r1 = new Runnable() {
533 @Override
534 public void run() {
535 ps.subscribe();
536 }
537 };
538 Runnable r2 = new Runnable() {
539 @Override
540 public void run() {
541 to.dispose();
542 }
543 };
544
545 TestHelper.race(r1, r2);
546 }
547 }
548
549 @Test
550 public void addTerminateRance() throws Exception {
551
552 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
553 final PublishSubject<Integer> ps = PublishSubject.create();
554
555 Runnable r1 = new Runnable() {
556 @Override
557 public void run() {
558 ps.subscribe();
559 }
560 };
561 Runnable r2 = new Runnable() {
562 @Override
563 public void run() {
564 ps.onComplete();
565 }
566 };
567
568 TestHelper.race(r1, r2);
569 }
570 }
571
572 @Test
573 public void addCompleteRance() throws Exception {
574
575 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
576 final PublishSubject<Integer> ps = PublishSubject.create();
577
578 final TestObserver<Integer> to = new TestObserver<>();
579
580 Runnable r1 = new Runnable() {
581 @Override
582 public void run() {
583 ps.subscribe(to);
584 }
585 };
586 Runnable r2 = new Runnable() {
587 @Override
588 public void run() {
589 ps.onComplete();
590 }
591 };
592
593 TestHelper.race(r1, r2);
594
595 to.awaitDone(5, TimeUnit.SECONDS)
596 .assertResult();
597 }
598 }
599
600 @Test
601 public void subscribeToAfterComplete() {
602 PublishSubject<Integer> ps = PublishSubject.create();
603
604 ps.onComplete();
605
606 PublishSubject<Integer> ps2 = PublishSubject.create();
607
608 ps2.subscribe(ps);
609
610 assertFalse(ps2.hasObservers());
611 }
612
613 @Test
614 public void subscribedTo() {
615 PublishSubject<Integer> ps = PublishSubject.create();
616 PublishSubject<Integer> ps2 = PublishSubject.create();
617
618 ps.subscribe(ps2);
619
620 TestObserver<Integer> to = ps2.test();
621
622 ps.onNext(1);
623 ps.onNext(2);
624 ps.onComplete();
625
626 to.assertResult(1, 2);
627 }
628 }