Debian Codegraph @

src/test/java/io/reactivex/rxjava3/subjects/MaybeSubjectTest.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
18 import java.io.IOException;
19 import java.util.List;
20
21 import org.junit.Test;
22
23 import io.reactivex.rxjava3.core.*;
24 import io.reactivex.rxjava3.disposables.*;
25 import io.reactivex.rxjava3.observers.TestObserver;
26 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
27 import io.reactivex.rxjava3.testsupport.TestHelper;
28
29 public class MaybeSubjectTest extends RxJavaTest {
30
31 @Test
32 public void success() {
33 MaybeSubject<Integer> ms = MaybeSubject.create();
34
35 assertFalse(ms.hasValue());
36 assertNull(ms.getValue());
37 assertFalse(ms.hasComplete());
38 assertFalse(ms.hasThrowable());
39 assertNull(ms.getThrowable());
40 assertFalse(ms.hasObservers());
41 assertEquals(0, ms.observerCount());
42
43 TestObserver<Integer> to = ms.test();
44
45 to.assertEmpty();
46
47 assertTrue(ms.hasObservers());
48 assertEquals(1, ms.observerCount());
49
50 ms.onSuccess(1);
51
52 assertTrue(ms.hasValue());
53 assertEquals(1, ms.getValue().intValue());
54 assertFalse(ms.hasComplete());
55 assertFalse(ms.hasThrowable());
56 assertNull(ms.getThrowable());
57 assertFalse(ms.hasObservers());
58 assertEquals(0, ms.observerCount());
59
60 to.assertResult(1);
61
62 ms.test().assertResult(1);
63
64 assertTrue(ms.hasValue());
65 assertEquals(1, ms.getValue().intValue());
66 assertFalse(ms.hasComplete());
67 assertFalse(ms.hasThrowable());
68 assertNull(ms.getThrowable());
69 assertFalse(ms.hasObservers());
70 assertEquals(0, ms.observerCount());
71 }
72
73 @Test
74 public void once() {
75 MaybeSubject<Integer> ms = MaybeSubject.create();
76
77 TestObserver<Integer> to = ms.test();
78
79 ms.onSuccess(1);
80 ms.onSuccess(2);
81
82 List<Throwable> errors = TestHelper.trackPluginErrors();
83 try {
84 ms.onError(new IOException());
85
86 TestHelper.assertUndeliverable(errors, 0, IOException.class);
87 } finally {
88 RxJavaPlugins.reset();
89 }
90 ms.onComplete();
91
92 to.assertResult(1);
93 }
94
95 @Test
96 public void error() {
97 MaybeSubject<Integer> ms = MaybeSubject.create();
98
99 assertFalse(ms.hasValue());
100 assertNull(ms.getValue());
101 assertFalse(ms.hasComplete());
102 assertFalse(ms.hasThrowable());
103 assertNull(ms.getThrowable());
104 assertFalse(ms.hasObservers());
105 assertEquals(0, ms.observerCount());
106
107 TestObserver<Integer> to = ms.test();
108
109 to.assertEmpty();
110
111 assertTrue(ms.hasObservers());
112 assertEquals(1, ms.observerCount());
113
114 ms.onError(new IOException());
115
116 assertFalse(ms.hasValue());
117 assertNull(ms.getValue());
118 assertFalse(ms.hasComplete());
119 assertTrue(ms.hasThrowable());
120 assertTrue(ms.getThrowable().toString(), ms.getThrowable() instanceof IOException);
121 assertFalse(ms.hasObservers());
122 assertEquals(0, ms.observerCount());
123
124 to.assertFailure(IOException.class);
125
126 ms.test().assertFailure(IOException.class);
127
128 assertFalse(ms.hasValue());
129 assertNull(ms.getValue());
130 assertFalse(ms.hasComplete());
131 assertTrue(ms.hasThrowable());
132 assertTrue(ms.getThrowable().toString(), ms.getThrowable() instanceof IOException);
133 assertFalse(ms.hasObservers());
134 assertEquals(0, ms.observerCount());
135 }
136
137 @Test
138 public void complete() {
139 MaybeSubject<Integer> ms = MaybeSubject.create();
140
141 assertFalse(ms.hasValue());
142 assertNull(ms.getValue());
143 assertFalse(ms.hasComplete());
144 assertFalse(ms.hasThrowable());
145 assertNull(ms.getThrowable());
146 assertFalse(ms.hasObservers());
147 assertEquals(0, ms.observerCount());
148
149 TestObserver<Integer> to = ms.test();
150
151 to.assertEmpty();
152
153 assertTrue(ms.hasObservers());
154 assertEquals(1, ms.observerCount());
155
156 ms.onComplete();
157
158 assertFalse(ms.hasValue());
159 assertNull(ms.getValue());
160 assertTrue(ms.hasComplete());
161 assertFalse(ms.hasThrowable());
162 assertNull(ms.getThrowable());
163 assertFalse(ms.hasObservers());
164 assertEquals(0, ms.observerCount());
165
166 to.assertResult();
167
168 ms.test().assertResult();
169
170 assertFalse(ms.hasValue());
171 assertNull(ms.getValue());
172 assertTrue(ms.hasComplete());
173 assertFalse(ms.hasThrowable());
174 assertNull(ms.getThrowable());
175 assertFalse(ms.hasObservers());
176 assertEquals(0, ms.observerCount());
177 }
178
179 @Test
180 public void cancelOnArrival() {
181 MaybeSubject.create()
182 .test(true)
183 .assertEmpty();
184 }
185
186 @Test
187 public void cancelOnArrival2() {
188 MaybeSubject<Integer> ms = MaybeSubject.create();
189
190 ms.test();
191
192 ms
193 .test(true)
194 .assertEmpty();
195 }
196
197 @Test
198 public void dispose() {
199 TestHelper.checkDisposed(MaybeSubject.create());
200 }
201
202 @Test
203 public void disposeTwice() {
204 MaybeSubject.create()
205 .subscribe(new MaybeObserver<Object>() {
206 @Override
207 public void onSubscribe(Disposable d) {
208 assertFalse(d.isDisposed());
209
210 d.dispose();
211 d.dispose();
212
213 assertTrue(d.isDisposed());
214 }
215
216 @Override
217 public void onSuccess(Object value) {
218
219 }
220
221 @Override
222 public void onError(Throwable e) {
223
224 }
225
226 @Override
227 public void onComplete() {
228
229 }
230 });
231 }
232
233 @Test
234 public void onSubscribeDispose() {
235 MaybeSubject<Integer> ms = MaybeSubject.create();
236
237 Disposable d = Disposable.empty();
238
239 ms.onSubscribe(d);
240
241 assertFalse(d.isDisposed());
242
243 ms.onComplete();
244
245 d = Disposable.empty();
246
247 ms.onSubscribe(d);
248
249 assertTrue(d.isDisposed());
250 }
251
252 @Test
253 public void addRemoveRace() {
254 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
255 final MaybeSubject<Integer> ms = MaybeSubject.create();
256
257 final TestObserver<Integer> to = ms.test();
258
259 Runnable r1 = new Runnable() {
260 @Override
261 public void run() {
262 ms.test();
263 }
264 };
265
266 Runnable r2 = new Runnable() {
267 @Override
268 public void run() {
269 to.dispose();
270 }
271 };
272 TestHelper.race(r1, r2);
273 }
274 }
275 }