Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableCacheTest.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.operators.completable;
15
16 import static org.junit.Assert.*;
17
18 import org.junit.Test;
19
20 import io.reactivex.rxjava3.core.*;
21 import io.reactivex.rxjava3.disposables.Disposable;
22 import io.reactivex.rxjava3.exceptions.TestException;
23 import io.reactivex.rxjava3.functions.*;
24 import io.reactivex.rxjava3.internal.disposables.EmptyDisposable;
25 import io.reactivex.rxjava3.observers.TestObserver;
26 import io.reactivex.rxjava3.subjects.PublishSubject;
27 import io.reactivex.rxjava3.testsupport.TestHelper;
28
29 public class CompletableCacheTest extends RxJavaTest implements Consumer<Object>, Action {
30
31 volatile int count;
32
33 @Override
34 public void accept(Object t) throws Exception {
35 count++;
36 }
37
38 @Override
39 public void run() throws Exception {
40 count++;
41 }
42
43 @Test
44 public void normal() {
45 Completable c = Completable.complete()
46 .doOnSubscribe(this)
47 .cache();
48
49 assertEquals(0, count);
50
51 c.test().assertResult();
52
53 assertEquals(1, count);
54
55 c.test().assertResult();
56
57 assertEquals(1, count);
58
59 c.test().assertResult();
60
61 assertEquals(1, count);
62 }
63
64 @Test
65 public void error() {
66 Completable c = Completable.error(new TestException())
67 .doOnSubscribe(this)
68 .cache();
69
70 assertEquals(0, count);
71
72 c.test().assertFailure(TestException.class);
73
74 assertEquals(1, count);
75
76 c.test().assertFailure(TestException.class);
77
78 assertEquals(1, count);
79
80 c.test().assertFailure(TestException.class);
81
82 assertEquals(1, count);
83 }
84
85 @Test
86 public void crossDispose() {
87 PublishSubject<Integer> ps = PublishSubject.create();
88
89 final TestObserver<Void> to1 = new TestObserver<>();
90
91 final TestObserver<Void> to2 = new TestObserver<Void>() {
92 @Override
93 public void onComplete() {
94 super.onComplete();
95 to1.dispose();
96 }
97 };
98
99 Completable c = ps.ignoreElements().cache();
100
101 c.subscribe(to2);
102 c.subscribe(to1);
103
104 ps.onComplete();
105
106 to1.assertEmpty();
107 to2.assertResult();
108 }
109
110 @Test
111 public void crossDisposeOnError() {
112 PublishSubject<Integer> ps = PublishSubject.create();
113
114 final TestObserver<Void> to1 = new TestObserver<>();
115
116 final TestObserver<Void> to2 = new TestObserver<Void>() {
117 @Override
118 public void onError(Throwable ex) {
119 super.onError(ex);
120 to1.dispose();
121 }
122 };
123
124 Completable c = ps.ignoreElements().cache();
125
126 c.subscribe(to2);
127 c.subscribe(to1);
128
129 ps.onError(new TestException());
130
131 to1.assertEmpty();
132 to2.assertFailure(TestException.class);
133 }
134
135 @Test
136 public void dispose() {
137 PublishSubject<Integer> ps = PublishSubject.create();
138
139 Completable c = ps.ignoreElements().cache();
140
141 assertFalse(ps.hasObservers());
142
143 TestObserver<Void> to1 = c.test();
144
145 assertTrue(ps.hasObservers());
146
147 to1.dispose();
148
149 assertTrue(ps.hasObservers());
150
151 TestObserver<Void> to2 = c.test();
152
153 TestObserver<Void> to3 = c.test();
154 to3.dispose();
155
156 TestObserver<Void> to4 = c.test(true);
157 to3.dispose();
158
159 ps.onComplete();
160
161 to1.assertEmpty();
162
163 to2.assertResult();
164
165 to3.assertEmpty();
166
167 to4.assertEmpty();
168 }
169
170 @Test
171 public void subscribeRace() {
172 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
173 PublishSubject<Integer> ps = PublishSubject.create();
174
175 final Completable c = ps.ignoreElements().cache();
176
177 final TestObserver<Void> to1 = new TestObserver<>();
178
179 final TestObserver<Void> to2 = new TestObserver<>();
180
181 Runnable r1 = new Runnable() {
182 @Override
183 public void run() {
184 c.subscribe(to1);
185 }
186 };
187 Runnable r2 = new Runnable() {
188 @Override
189 public void run() {
190 c.subscribe(to2);
191 }
192 };
193
194 TestHelper.race(r1, r2);
195
196 ps.onComplete();
197
198 to1.assertResult();
199 to2.assertResult();
200 }
201 }
202
203 @Test
204 public void subscribeDisposeRace() {
205 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
206 PublishSubject<Integer> ps = PublishSubject.create();
207
208 final Completable c = ps.ignoreElements().cache();
209
210 final TestObserver<Void> to1 = c.test();
211
212 final TestObserver<Void> to2 = new TestObserver<>();
213
214 Runnable r1 = new Runnable() {
215 @Override
216 public void run() {
217 to1.dispose();
218 }
219 };
220 Runnable r2 = new Runnable() {
221 @Override
222 public void run() {
223 c.subscribe(to2);
224 }
225 };
226
227 TestHelper.race(r1, r2);
228
229 ps.onComplete();
230
231 to1.assertEmpty();
232 to2.assertResult();
233 }
234 }
235
236 @Test
237 public void doubleDispose() {
238 PublishSubject<Integer> ps = PublishSubject.create();
239
240 final TestObserver<Void> to = new TestObserver<>();
241
242 ps.ignoreElements().cache()
243 .subscribe(new CompletableObserver() {
244
245 @Override
246 public void onSubscribe(Disposable d) {
247 to.onSubscribe(EmptyDisposable.INSTANCE);
248 d.dispose();
249 d.dispose();
250 }
251
252 @Override
253 public void onComplete() {
254 to.onComplete();
255 }
256
257 @Override
258 public void onError(Throwable e) {
259 to.onError(e);
260 }
261 });
262
263 ps.onComplete();
264
265 to.assertEmpty();
266 }
267 }