Debian Codegraph @

src/test/java/io/reactivex/rxjava3/observers/ResourceMaybeObserverTest.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.observers;
15
16 import static org.junit.Assert.*;
17
18 import java.util.*;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.core.*;
23 import io.reactivex.rxjava3.disposables.*;
24 import io.reactivex.rxjava3.exceptions.TestException;
25 import io.reactivex.rxjava3.internal.util.EndConsumerHelper;
26 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
27 import io.reactivex.rxjava3.testsupport.TestHelper;
28
29 public class ResourceMaybeObserverTest extends RxJavaTest {
30 static final class TestResourceMaybeObserver<T> extends ResourceMaybeObserver<T> {
31 T value;
32
33 final List<Throwable> errors = new ArrayList<>();
34
35 int complete;
36
37 int start;
38
39 @Override
40 protected void onStart() {
41 super.onStart();
42
43 start++;
44 }
45
46 @Override
47 public void onSuccess(final T value) {
48 this.value = value;
49
50 dispose();
51 }
52
53 @Override
54 public void onComplete() {
55 complete++;
56
57 dispose();
58 }
59
60 @Override
61 public void onError(Throwable e) {
62 errors.add(e);
63
64 dispose();
65 }
66 }
67
68 @Test(expected = NullPointerException.class)
69 public void nullResource() {
70 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
71 rmo.add(null);
72 }
73
74 @Test
75 public void addResources() {
76 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
77
78 assertFalse(rmo.isDisposed());
79
80 Disposable d = Disposable.empty();
81
82 rmo.add(d);
83
84 assertFalse(d.isDisposed());
85
86 rmo.dispose();
87
88 assertTrue(rmo.isDisposed());
89
90 assertTrue(d.isDisposed());
91
92 rmo.dispose();
93
94 assertTrue(rmo.isDisposed());
95
96 assertTrue(d.isDisposed());
97 }
98
99 @Test
100 public void onCompleteCleansUp() {
101 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
102
103 assertFalse(rmo.isDisposed());
104
105 Disposable d = Disposable.empty();
106
107 rmo.add(d);
108
109 assertFalse(d.isDisposed());
110
111 rmo.onComplete();
112
113 assertTrue(rmo.isDisposed());
114
115 assertTrue(d.isDisposed());
116 }
117
118 @Test
119 public void onSuccessCleansUp() {
120 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
121
122 assertFalse(rmo.isDisposed());
123
124 Disposable d = Disposable.empty();
125
126 rmo.add(d);
127
128 assertFalse(d.isDisposed());
129
130 rmo.onSuccess(1);
131
132 assertTrue(rmo.isDisposed());
133
134 assertTrue(d.isDisposed());
135 }
136
137 @Test
138 public void onErrorCleansUp() {
139 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
140
141 assertFalse(rmo.isDisposed());
142
143 Disposable d = Disposable.empty();
144
145 rmo.add(d);
146
147 assertFalse(d.isDisposed());
148
149 rmo.onError(new TestException());
150
151 assertTrue(rmo.isDisposed());
152
153 assertTrue(d.isDisposed());
154 }
155
156 @Test
157 public void normal() {
158 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
159
160 assertFalse(rmo.isDisposed());
161 assertEquals(0, rmo.start);
162 assertNull(rmo.value);
163 assertTrue(rmo.errors.isEmpty());
164
165 Maybe.just(1).subscribe(rmo);
166
167 assertTrue(rmo.isDisposed());
168 assertEquals(1, rmo.start);
169 assertEquals(Integer.valueOf(1), rmo.value);
170 assertEquals(0, rmo.complete);
171 assertTrue(rmo.errors.isEmpty());
172 }
173
174 @Test
175 public void empty() {
176 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
177
178 assertFalse(rmo.isDisposed());
179 assertEquals(0, rmo.start);
180 assertNull(rmo.value);
181 assertTrue(rmo.errors.isEmpty());
182
183 Maybe.<Integer>empty().subscribe(rmo);
184
185 assertTrue(rmo.isDisposed());
186 assertEquals(1, rmo.start);
187 assertNull(rmo.value);
188 assertEquals(1, rmo.complete);
189 assertTrue(rmo.errors.isEmpty());
190 }
191
192 @Test
193 public void error() {
194 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
195
196 assertFalse(rmo.isDisposed());
197 assertEquals(0, rmo.start);
198 assertNull(rmo.value);
199 assertTrue(rmo.errors.isEmpty());
200
201 final RuntimeException error = new RuntimeException("error");
202 Maybe.<Integer>error(error).subscribe(rmo);
203
204 assertTrue(rmo.isDisposed());
205 assertEquals(1, rmo.start);
206 assertNull(rmo.value);
207 assertEquals(0, rmo.complete);
208 assertEquals(1, rmo.errors.size());
209 assertTrue(rmo.errors.contains(error));
210 }
211
212 @Test
213 public void startOnce() {
214
215 List<Throwable> error = TestHelper.trackPluginErrors();
216
217 try {
218 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
219
220 rmo.onSubscribe(Disposable.empty());
221
222 Disposable d = Disposable.empty();
223
224 rmo.onSubscribe(d);
225
226 assertTrue(d.isDisposed());
227
228 assertEquals(1, rmo.start);
229
230 TestHelper.assertError(error, 0, IllegalStateException.class, EndConsumerHelper.composeMessage(rmo.getClass().getName()));
231 } finally {
232 RxJavaPlugins.reset();
233 }
234 }
235
236 @Test
237 public void dispose() {
238 TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<>();
239 rmo.dispose();
240
241 Disposable d = Disposable.empty();
242
243 rmo.onSubscribe(d);
244
245 assertTrue(d.isDisposed());
246
247 assertEquals(0, rmo.start);
248 }
249 }