Debian Codegraph @

src/test/java/io/reactivex/rxjava3/observers/ResourceObserverTest.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.Observable;
23 import io.reactivex.rxjava3.core.RxJavaTest;
24 import io.reactivex.rxjava3.disposables.*;
25 import io.reactivex.rxjava3.exceptions.TestException;
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 ResourceObserverTest extends RxJavaTest {
31
32 static final class TestResourceObserver<T> extends ResourceObserver<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
68 @Test(expected = NullPointerException.class)
69 public void nullResource() {
70 TestResourceObserver<Integer> ro = new TestResourceObserver<>();
71 ro.add(null);
72 }
73
74 @Test
75 public void addResources() {
76 TestResourceObserver<Integer> ro = new TestResourceObserver<>();
77
78 assertFalse(ro.isDisposed());
79
80 Disposable d = Disposable.empty();
81
82 ro.add(d);
83
84 assertFalse(d.isDisposed());
85
86 ro.dispose();
87
88 assertTrue(ro.isDisposed());
89
90 assertTrue(d.isDisposed());
91
92 ro.dispose();
93
94 assertTrue(ro.isDisposed());
95
96 assertTrue(d.isDisposed());
97 }
98
99 @Test
100 public void onCompleteCleansUp() {
101 TestResourceObserver<Integer> ro = new TestResourceObserver<>();
102
103 assertFalse(ro.isDisposed());
104
105 Disposable d = Disposable.empty();
106
107 ro.add(d);
108
109 assertFalse(d.isDisposed());
110
111 ro.onComplete();
112
113 assertTrue(ro.isDisposed());
114
115 assertTrue(d.isDisposed());
116 }
117
118 @Test
119 public void onErrorCleansUp() {
120 TestResourceObserver<Integer> ro = new TestResourceObserver<>();
121
122 assertFalse(ro.isDisposed());
123
124 Disposable d = Disposable.empty();
125
126 ro.add(d);
127
128 assertFalse(d.isDisposed());
129
130 ro.onError(new TestException());
131
132 assertTrue(ro.isDisposed());
133
134 assertTrue(d.isDisposed());
135 }
136
137 @Test
138 public void normal() {
139 TestResourceObserver<Integer> tc = new TestResourceObserver<>();
140
141 assertFalse(tc.isDisposed());
142 assertEquals(0, tc.start);
143 assertTrue(tc.values.isEmpty());
144 assertTrue(tc.errors.isEmpty());
145
146 Observable.just(1).subscribe(tc);
147
148 assertTrue(tc.isDisposed());
149 assertEquals(1, tc.start);
150 assertEquals(1, tc.values.get(0).intValue());
151 assertTrue(tc.errors.isEmpty());
152 }
153
154 @Test
155 public void error() {
156 TestResourceObserver<Integer> tc = new TestResourceObserver<>();
157
158 assertFalse(tc.isDisposed());
159 assertEquals(0, tc.start);
160 assertTrue(tc.values.isEmpty());
161 assertTrue(tc.errors.isEmpty());
162
163 final RuntimeException error = new RuntimeException("error");
164 Observable.<Integer>error(error).subscribe(tc);
165
166 assertTrue(tc.isDisposed());
167 assertEquals(1, tc.start);
168 assertTrue(tc.values.isEmpty());
169 assertEquals(1, tc.errors.size());
170 assertTrue(tc.errors.contains(error));
171 }
172
173 @Test
174 public void startOnce() {
175
176 List<Throwable> error = TestHelper.trackPluginErrors();
177
178 try {
179 TestResourceObserver<Integer> tc = new TestResourceObserver<>();
180
181 tc.onSubscribe(Disposable.empty());
182
183 Disposable d = Disposable.empty();
184
185 tc.onSubscribe(d);
186
187 assertTrue(d.isDisposed());
188
189 assertEquals(1, tc.start);
190
191 TestHelper.assertError(error, 0, IllegalStateException.class, EndConsumerHelper.composeMessage(tc.getClass().getName()));
192 } finally {
193 RxJavaPlugins.reset();
194 }
195 }
196
197 @Test
198 public void dispose() {
199 TestResourceObserver<Integer> tc = new TestResourceObserver<>();
200 tc.dispose();
201
202 Disposable d = Disposable.empty();
203
204 tc.onSubscribe(d);
205
206 assertTrue(d.isDisposed());
207
208 assertEquals(0, tc.start);
209 }
210 }