Debian Codegraph @

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