Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableOnErrorCompleteTest.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.observable;
15
16 import static org.junit.Assert.*;
17
18 import java.io.IOException;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.core.Observable;
23 import io.reactivex.rxjava3.exceptions.*;
24 import io.reactivex.rxjava3.observers.TestObserver;
25 import io.reactivex.rxjava3.subjects.PublishSubject;
26 import io.reactivex.rxjava3.testsupport.*;
27
28 public class ObservableOnErrorCompleteTest {
29
30 @Test
31 public void normal() {
32 Observable.range(1, 10)
33 .onErrorComplete()
34 .test()
35 .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
36 }
37
38 @Test
39 public void empty() {
40 Observable.empty()
41 .onErrorComplete()
42 .test()
43 .assertResult();
44 }
45
46 @Test
47 public void error() throws Throwable {
48 TestHelper.withErrorTracking(errors -> {
49 Observable.error(new TestException())
50 .onErrorComplete()
51 .test()
52 .assertResult();
53
54 assertTrue("" + errors, errors.isEmpty());
55 });
56 }
57
58 @Test
59 public void errorMatches() throws Throwable {
60 TestHelper.withErrorTracking(errors -> {
61 Observable.error(new TestException())
62 .onErrorComplete(error -> error instanceof TestException)
63 .test()
64 .assertResult();
65
66 assertTrue("" + errors, errors.isEmpty());
67 });
68 }
69
70 @Test
71 public void errorNotMatches() throws Throwable {
72 TestHelper.withErrorTracking(errors -> {
73 Observable.error(new IOException())
74 .onErrorComplete(error -> error instanceof TestException)
75 .test()
76 .assertFailure(IOException.class);
77
78 assertTrue("" + errors, errors.isEmpty());
79 });
80 }
81
82 @Test
83 public void errorPredicateCrash() throws Throwable {
84 TestHelper.withErrorTracking(errors -> {
85 TestObserverEx<Object> to = Observable.error(new IOException())
86 .onErrorComplete(error -> { throw new TestException(); })
87 .subscribeWith(new TestObserverEx<>())
88 .assertFailure(CompositeException.class);
89
90 TestHelper.assertError(to, 0, IOException.class);
91 TestHelper.assertError(to, 1, TestException.class);
92
93 assertTrue("" + errors, errors.isEmpty());
94 });
95 }
96
97 @Test
98 public void itemsThenError() throws Throwable {
99 TestHelper.withErrorTracking(errors -> {
100 Observable.range(1, 5)
101 .map(v -> 4 / (3 - v))
102 .onErrorComplete()
103 .test()
104 .assertResult(2, 4);
105
106 assertTrue("" + errors, errors.isEmpty());
107 });
108 }
109
110 @Test
111 public void dispose() {
112 PublishSubject<Integer> ps = PublishSubject.create();
113
114 TestObserver<Integer> to = ps
115 .onErrorComplete()
116 .test();
117
118 assertTrue("No subscribers?!", ps.hasObservers());
119
120 to.dispose();
121
122 assertFalse("Still subscribers?!", ps.hasObservers());
123 }
124
125 @Test
126 public void onSubscribe() {
127 TestHelper.checkDoubleOnSubscribeObservable(f -> f.onErrorComplete());
128 }
129
130 @Test
131 public void isDisposed() {
132 TestHelper.checkDisposed(PublishSubject.create().onErrorComplete());
133 }
134 }