Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/util/AtomicThrowableTest.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.util;
15
16 import static org.junit.Assert.*;
17
18 import java.util.List;
19
20 import io.reactivex.rxjava3.disposables.Disposable;
21 import org.junit.Test;
22
23 import io.reactivex.rxjava3.core.*;
24 import io.reactivex.rxjava3.exceptions.TestException;
25 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
26 import io.reactivex.rxjava3.observers.TestObserver;
27 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
28 import io.reactivex.rxjava3.subscribers.TestSubscriber;
29 import io.reactivex.rxjava3.testsupport.TestHelper;
30
31 public class AtomicThrowableTest extends RxJavaTest {
32
33 @Test
34 public void isTerminated() {
35 AtomicThrowable ex = new AtomicThrowable();
36
37 assertFalse(ex.isTerminated());
38
39 assertNull(ex.terminate());
40
41 assertTrue(ex.isTerminated());
42 }
43
44 @Test
45 public void tryTerminateAndReportNull() {
46 List<Throwable> errors = TestHelper.trackPluginErrors();
47 try {
48
49 AtomicThrowable ex = new AtomicThrowable();
50 ex.tryTerminateAndReport();
51
52 assertTrue("" + errors, errors.isEmpty());
53 } finally {
54 RxJavaPlugins.reset();
55 }
56 }
57
58 @Test
59 public void tryTerminateAndReportAlreadyTerminated() {
60 List<Throwable> errors = TestHelper.trackPluginErrors();
61 try {
62
63 AtomicThrowable ex = new AtomicThrowable();
64 ex.terminate();
65
66 ex.tryTerminateAndReport();
67
68 assertTrue("" + errors, errors.isEmpty());
69 } finally {
70 RxJavaPlugins.reset();
71 }
72 }
73
74 @Test
75 public void tryTerminateAndReportHasError() {
76 List<Throwable> errors = TestHelper.trackPluginErrors();
77 try {
78
79 AtomicThrowable ex = new AtomicThrowable();
80 ex.set(new TestException());
81
82 ex.tryTerminateAndReport();
83
84 TestHelper.assertUndeliverable(errors, 0, TestException.class);
85
86 assertEquals(1, errors.size());
87 } finally {
88 RxJavaPlugins.reset();
89 }
90 }
91
92 @Test
93 public void tryTerminateConsumerSubscriberNoError() {
94 TestSubscriber<Object> ts = new TestSubscriber<>();
95 ts.onSubscribe(new BooleanSubscription());
96
97 AtomicThrowable ex = new AtomicThrowable();
98 ex.tryTerminateConsumer(ts);
99 ts.assertResult();
100 }
101
102 @Test
103 public void tryTerminateConsumerSubscriberError() {
104 TestSubscriber<Object> ts = new TestSubscriber<>();
105 ts.onSubscribe(new BooleanSubscription());
106
107 AtomicThrowable ex = new AtomicThrowable();
108 ex.set(new TestException());
109 ex.tryTerminateConsumer(ts);
110 ts.assertFailure(TestException.class);
111 }
112
113 @Test
114 public void tryTerminateConsumerSubscriberTerminated() {
115 TestSubscriber<Object> ts = new TestSubscriber<>();
116 ts.onSubscribe(new BooleanSubscription());
117
118 AtomicThrowable ex = new AtomicThrowable();
119 ex.terminate();
120 ex.tryTerminateConsumer(ts);
121 ts.assertEmpty();
122 }
123
124 @Test
125 public void tryTerminateConsumerObserverNoError() {
126 TestObserver<Object> to = new TestObserver<>();
127 to.onSubscribe(Disposable.empty());
128
129 AtomicThrowable ex = new AtomicThrowable();
130 ex.tryTerminateConsumer((Observer<Object>)to);
131 to.assertResult();
132 }
133
134 @Test
135 public void tryTerminateConsumerObserverError() {
136 TestObserver<Object> to = new TestObserver<>();
137 to.onSubscribe(Disposable.empty());
138
139 AtomicThrowable ex = new AtomicThrowable();
140 ex.set(new TestException());
141 ex.tryTerminateConsumer((Observer<Object>)to);
142 to.assertFailure(TestException.class);
143 }
144
145 @Test
146 public void tryTerminateConsumerObserverTerminated() {
147 TestObserver<Object> to = new TestObserver<>();
148 to.onSubscribe(Disposable.empty());
149
150 AtomicThrowable ex = new AtomicThrowable();
151 ex.terminate();
152 ex.tryTerminateConsumer((Observer<Object>)to);
153 to.assertEmpty();
154 }
155
156 @Test
157 public void tryTerminateConsumerMaybeObserverNoError() {
158 TestObserver<Object> to = new TestObserver<>();
159 to.onSubscribe(Disposable.empty());
160
161 AtomicThrowable ex = new AtomicThrowable();
162 ex.tryTerminateConsumer((MaybeObserver<Object>)to);
163 to.assertResult();
164 }
165
166 @Test
167 public void tryTerminateConsumerMaybeObserverError() {
168 TestObserver<Object> to = new TestObserver<>();
169 to.onSubscribe(Disposable.empty());
170
171 AtomicThrowable ex = new AtomicThrowable();
172 ex.set(new TestException());
173 ex.tryTerminateConsumer((MaybeObserver<Object>)to);
174 to.assertFailure(TestException.class);
175 }
176
177 @Test
178 public void tryTerminateConsumerMaybeObserverTerminated() {
179 TestObserver<Object> to = new TestObserver<>();
180 to.onSubscribe(Disposable.empty());
181
182 AtomicThrowable ex = new AtomicThrowable();
183 ex.terminate();
184 ex.tryTerminateConsumer((MaybeObserver<Object>)to);
185 to.assertEmpty();
186 }
187
188 @Test
189 public void tryTerminateConsumerSingleNoError() {
190 TestObserver<Object> to = new TestObserver<>();
191 to.onSubscribe(Disposable.empty());
192
193 AtomicThrowable ex = new AtomicThrowable();
194 ex.tryTerminateConsumer((SingleObserver<Object>)to);
195 to.assertEmpty();
196 }
197
198 @Test
199 public void tryTerminateConsumerSingleError() {
200 TestObserver<Object> to = new TestObserver<>();
201 to.onSubscribe(Disposable.empty());
202
203 AtomicThrowable ex = new AtomicThrowable();
204 ex.set(new TestException());
205 ex.tryTerminateConsumer((SingleObserver<Object>)to);
206 to.assertFailure(TestException.class);
207 }
208
209 @Test
210 public void tryTerminateConsumerSingleTerminated() {
211 TestObserver<Object> to = new TestObserver<>();
212 to.onSubscribe(Disposable.empty());
213
214 AtomicThrowable ex = new AtomicThrowable();
215 ex.terminate();
216 ex.tryTerminateConsumer((SingleObserver<Object>)to);
217 to.assertEmpty();
218 }
219
220 @Test
221 public void tryTerminateConsumerCompletableObserverNoError() {
222 TestObserver<Object> to = new TestObserver<>();
223 to.onSubscribe(Disposable.empty());
224
225 AtomicThrowable ex = new AtomicThrowable();
226 ex.tryTerminateConsumer((CompletableObserver)to);
227 to.assertResult();
228 }
229
230 @Test
231 public void tryTerminateConsumerCompletableObserverError() {
232 TestObserver<Object> to = new TestObserver<>();
233 to.onSubscribe(Disposable.empty());
234
235 AtomicThrowable ex = new AtomicThrowable();
236 ex.set(new TestException());
237 ex.tryTerminateConsumer((CompletableObserver)to);
238 to.assertFailure(TestException.class);
239 }
240
241 @Test
242 public void tryTerminateConsumerCompletableObserverTerminated() {
243 TestObserver<Object> to = new TestObserver<>();
244 to.onSubscribe(Disposable.empty());
245
246 AtomicThrowable ex = new AtomicThrowable();
247 ex.terminate();
248 ex.tryTerminateConsumer((CompletableObserver)to);
249 to.assertEmpty();
250 }
251
252 static <T> Emitter<T> wrapToEmitter(final Observer<T> observer) {
253 return new Emitter<T>() {
254 @Override
255 public void onNext(T value) {
256 observer.onNext(value);
257 }
258
259 @Override
260 public void onError(Throwable error) {
261 observer.onError(error);
262 }
263
264 @Override
265 public void onComplete() {
266 observer.onComplete();
267 }
268 };
269 }
270
271 @Test
272 public void tryTerminateConsumerEmitterNoError() {
273 TestObserver<Object> to = new TestObserver<>();
274 to.onSubscribe(Disposable.empty());
275
276 AtomicThrowable ex = new AtomicThrowable();
277 ex.tryTerminateConsumer(wrapToEmitter(to));
278 to.assertResult();
279 }
280
281 @Test
282 public void tryTerminateConsumerEmitterError() {
283 TestObserver<Object> to = new TestObserver<>();
284 to.onSubscribe(Disposable.empty());
285
286 AtomicThrowable ex = new AtomicThrowable();
287 ex.set(new TestException());
288 ex.tryTerminateConsumer(wrapToEmitter(to));
289 to.assertFailure(TestException.class);
290 }
291
292 @Test
293 public void tryTerminateConsumerEmitterTerminated() {
294 TestObserver<Object> to = new TestObserver<>();
295 to.onSubscribe(Disposable.empty());
296
297 AtomicThrowable ex = new AtomicThrowable();
298 ex.terminate();
299 ex.tryTerminateConsumer(wrapToEmitter(to));
300 to.assertEmpty();
301 }
302
303 @Test
304 public void tryAddThrowableOrReportNull() {
305 List<Throwable> errors = TestHelper.trackPluginErrors();
306 try {
307
308 AtomicThrowable ex = new AtomicThrowable();
309 ex.tryAddThrowableOrReport(new TestException());
310
311 assertTrue("" + errors, errors.isEmpty());
312 } finally {
313 RxJavaPlugins.reset();
314 }
315 }
316
317 @Test
318 public void tryAddThrowableOrReportTerminated() {
319 List<Throwable> errors = TestHelper.trackPluginErrors();
320 try {
321
322 AtomicThrowable ex = new AtomicThrowable();
323 ex.terminate();
324
325 assertFalse(ex.tryAddThrowableOrReport(new TestException()));
326
327 assertFalse("" + errors, errors.isEmpty());
328 TestHelper.assertUndeliverable(errors, 0, TestException.class);
329 } finally {
330 RxJavaPlugins.reset();
331 }
332 }
333 }