Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableMergeWithCompletableTest.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 org.junit.Test;
19
20 import io.reactivex.rxjava3.core.*;
21 import io.reactivex.rxjava3.disposables.*;
22 import io.reactivex.rxjava3.exceptions.TestException;
23 import io.reactivex.rxjava3.functions.Action;
24 import io.reactivex.rxjava3.observers.TestObserver;
25 import io.reactivex.rxjava3.subjects.*;
26 import io.reactivex.rxjava3.testsupport.TestHelper;
27
28 public class ObservableMergeWithCompletableTest extends RxJavaTest {
29
30 @Test
31 public void normal() {
32 final TestObserver<Integer> to = new TestObserver<>();
33
34 Observable.range(1, 5).mergeWith(
35 Completable.fromAction(new Action() {
36 @Override
37 public void run() throws Exception {
38 to.onNext(100);
39 }
40 })
41 )
42 .subscribe(to);
43
44 to.assertResult(1, 2, 3, 4, 5, 100);
45 }
46
47 @Test
48 public void take() {
49 final TestObserver<Integer> to = new TestObserver<>();
50
51 Observable.range(1, 5).mergeWith(
52 Completable.complete()
53 )
54 .take(3)
55 .subscribe(to);
56
57 to.assertResult(1, 2, 3);
58 }
59
60 @Test
61 public void cancel() {
62 final PublishSubject<Integer> ps = PublishSubject.create();
63 final CompletableSubject cs = CompletableSubject.create();
64
65 TestObserver<Integer> to = ps.mergeWith(cs).test();
66
67 assertTrue(ps.hasObservers());
68 assertTrue(cs.hasObservers());
69
70 to.dispose();
71
72 assertFalse(ps.hasObservers());
73 assertFalse(cs.hasObservers());
74 }
75
76 @Test
77 public void mainError() {
78 Observable.error(new TestException())
79 .mergeWith(Completable.complete())
80 .test()
81 .assertFailure(TestException.class);
82 }
83
84 @Test
85 public void otherError() {
86 Observable.never()
87 .mergeWith(Completable.error(new TestException()))
88 .test()
89 .assertFailure(TestException.class);
90 }
91
92 @Test
93 public void completeRace() {
94 for (int i = 0; i < 1000; i++) {
95 final PublishSubject<Integer> ps = PublishSubject.create();
96 final CompletableSubject cs = CompletableSubject.create();
97
98 TestObserver<Integer> to = ps.mergeWith(cs).test();
99
100 Runnable r1 = new Runnable() {
101 @Override
102 public void run() {
103 ps.onNext(1);
104 ps.onComplete();
105 }
106 };
107
108 Runnable r2 = new Runnable() {
109 @Override
110 public void run() {
111 cs.onComplete();
112 }
113 };
114
115 TestHelper.race(r1, r2);
116
117 to.assertResult(1);
118 }
119 }
120
121 @Test
122 public void isDisposed() {
123 new Observable<Integer>() {
124 @Override
125 protected void subscribeActual(Observer<? super Integer> observer) {
126 observer.onSubscribe(Disposable.empty());
127
128 assertFalse(((Disposable)observer).isDisposed());
129
130 observer.onNext(1);
131
132 assertTrue(((Disposable)observer).isDisposed());
133 }
134 }.mergeWith(Completable.complete())
135 .take(1)
136 .test()
137 .assertResult(1);
138 }
139
140 @Test
141 public void cancelOtherOnMainError() {
142 PublishSubject<Integer> ps = PublishSubject.create();
143 CompletableSubject cs = CompletableSubject.create();
144
145 TestObserver<Integer> to = ps.mergeWith(cs).test();
146
147 assertTrue(ps.hasObservers());
148 assertTrue(cs.hasObservers());
149
150 ps.onError(new TestException());
151
152 to.assertFailure(TestException.class);
153
154 assertFalse("main has observers!", ps.hasObservers());
155 assertFalse("other has observers", cs.hasObservers());
156 }
157
158 @Test
159 public void cancelMainOnOtherError() {
160 PublishSubject<Integer> ps = PublishSubject.create();
161 CompletableSubject cs = CompletableSubject.create();
162
163 TestObserver<Integer> to = ps.mergeWith(cs).test();
164
165 assertTrue(ps.hasObservers());
166 assertTrue(cs.hasObservers());
167
168 cs.onError(new TestException());
169
170 to.assertFailure(TestException.class);
171
172 assertFalse("main has observers!", ps.hasObservers());
173 assertFalse("other has observers", cs.hasObservers());
174 }
175
176 @Test
177 public void undeliverableUponCancel() {
178 TestHelper.checkUndeliverableUponCancel(new ObservableConverter<Integer, Observable<Integer>>() {
179 @Override
180 public Observable<Integer> apply(Observable<Integer> upstream) {
181 return upstream.mergeWith(Completable.complete().hide());
182 }
183 });
184 }
185 }