Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeStartWithTest.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.maybe;
15
16 import static org.mockito.Mockito.*;
17
18 import org.junit.Test;
19
20 import io.reactivex.rxjava3.core.*;
21 import io.reactivex.rxjava3.exceptions.TestException;
22
23 public class MaybeStartWithTest {
24
25 @Test
26 public void justCompletableComplete() {
27 Maybe.just(1).startWith(Completable.complete())
28 .test()
29 .assertResult(1);
30 }
31
32 @Test
33 public void emptyCompletableComplete() {
34 Maybe.empty().startWith(Completable.complete())
35 .test()
36 .assertResult();
37 }
38
39 @Test
40 public void runCompletableError() {
41 Runnable run = mock(Runnable.class);
42
43 Maybe.fromRunnable(run).startWith(Completable.error(new TestException()))
44 .test()
45 .assertFailure(TestException.class);
46
47 verify(run, never()).run();
48 }
49
50 @Test
51 public void justSingleJust() {
52 Maybe.just(1).startWith(Single.just(2))
53 .test()
54 .assertResult(2, 1);
55 }
56
57 @Test
58 public void emptySingleJust() {
59 Runnable run = mock(Runnable.class);
60
61 Maybe.fromRunnable(run)
62 .startWith(Single.just(2))
63 .test()
64 .assertResult(2);
65
66 verify(run).run();
67 }
68
69 @Test
70 public void runSingleError() {
71 Runnable run = mock(Runnable.class);
72
73 Maybe.fromRunnable(run).startWith(Single.error(new TestException()))
74 .test()
75 .assertFailure(TestException.class);
76
77 verify(run, never()).run();
78 }
79
80 @Test
81 public void justMaybeJust() {
82 Maybe.just(1).startWith(Maybe.just(2))
83 .test()
84 .assertResult(2, 1);
85 }
86
87 @Test
88 public void emptyMaybeJust() {
89 Runnable run = mock(Runnable.class);
90
91 Maybe.fromRunnable(run)
92 .startWith(Maybe.just(2))
93 .test()
94 .assertResult(2);
95
96 verify(run).run();
97 }
98
99 @Test
100 public void runMaybeError() {
101 Runnable run = mock(Runnable.class);
102
103 Maybe.fromRunnable(run).startWith(Maybe.error(new TestException()))
104 .test()
105 .assertFailure(TestException.class);
106
107 verify(run, never()).run();
108 }
109
110 @Test
111 public void justObservableJust() {
112 Maybe.just(1).startWith(Observable.just(2, 3, 4, 5))
113 .test()
114 .assertResult(2, 3, 4, 5, 1);
115 }
116
117 @Test
118 public void emptyObservableJust() {
119 Runnable run = mock(Runnable.class);
120
121 Maybe.fromRunnable(run)
122 .startWith(Observable.just(2, 3, 4, 5))
123 .test()
124 .assertResult(2, 3, 4, 5);
125
126 verify(run).run();
127 }
128
129 @Test
130 public void emptyObservableEmpty() {
131 Runnable run = mock(Runnable.class);
132 Runnable run2 = mock(Runnable.class);
133
134 Maybe.fromRunnable(run)
135 .startWith(Observable.fromRunnable(run2))
136 .test()
137 .assertResult();
138
139 verify(run).run();
140 verify(run2).run();
141 }
142
143 @Test
144 public void runObservableError() {
145 Runnable run = mock(Runnable.class);
146
147 Maybe.fromRunnable(run).startWith(Observable.error(new TestException()))
148 .test()
149 .assertFailure(TestException.class);
150
151 verify(run, never()).run();
152 }
153
154 @Test
155 public void justFlowableJust() {
156 Maybe.just(1).startWith(Flowable.just(2, 3, 4, 5))
157 .test()
158 .assertResult(2, 3, 4, 5, 1);
159 }
160
161 @Test
162 public void emptyFlowableJust() {
163 Runnable run = mock(Runnable.class);
164
165 Maybe.fromRunnable(run)
166 .startWith(Flowable.just(2, 3, 4, 5))
167 .test()
168 .assertResult(2, 3, 4, 5);
169
170 verify(run).run();
171 }
172
173 @Test
174 public void emptyFlowableEmpty() {
175 Runnable run = mock(Runnable.class);
176 Runnable run2 = mock(Runnable.class);
177
178 Maybe.fromRunnable(run)
179 .startWith(Flowable.fromRunnable(run2))
180 .test()
181 .assertResult();
182
183 verify(run).run();
184 verify(run2).run();
185 }
186
187 @Test
188 public void runFlowableError() {
189 Runnable run = mock(Runnable.class);
190
191 Maybe.fromRunnable(run).startWith(Flowable.error(new TestException()))
192 .test()
193 .assertFailure(TestException.class);
194
195 verify(run, never()).run();
196 }
197 }