Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableDistinctUntilChangedTest.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.mockito.ArgumentMatchers.*;
17 import static org.mockito.Mockito.*;
18
19 import java.io.IOException;
20 import java.util.List;
21
22 import io.reactivex.rxjava3.disposables.Disposable;
23 import org.junit.*;
24 import org.mockito.InOrder;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.functions.*;
29 import io.reactivex.rxjava3.observers.TestObserver;
30 import io.reactivex.rxjava3.operators.QueueFuseable;
31 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
32 import io.reactivex.rxjava3.subjects.*;
33 import io.reactivex.rxjava3.testsupport.*;
34
35 public class ObservableDistinctUntilChangedTest extends RxJavaTest {
36
37 Observer<String> w;
38 Observer<String> w2;
39
40 // nulls lead to exceptions
41 final Function<String, String> TO_UPPER_WITH_EXCEPTION = new Function<String, String>() {
42 @Override
43 public String apply(String s) {
44 if (s.equals("x")) {
45 return "xx";
46 }
47 return s.toUpperCase();
48 }
49 };
50
51 @Before
52 public void before() {
53 w = TestHelper.mockObserver();
54 w2 = TestHelper.mockObserver();
55 }
56
57 @Test
58 public void distinctUntilChangedOfNone() {
59 Observable<String> src = Observable.empty();
60 src.distinctUntilChanged().subscribe(w);
61
62 verify(w, never()).onNext(anyString());
63 verify(w, never()).onError(any(Throwable.class));
64 verify(w, times(1)).onComplete();
65 }
66
67 @Test
68 public void distinctUntilChangedOfNoneWithKeySelector() {
69 Observable<String> src = Observable.empty();
70 src.distinctUntilChanged(TO_UPPER_WITH_EXCEPTION).subscribe(w);
71
72 verify(w, never()).onNext(anyString());
73 verify(w, never()).onError(any(Throwable.class));
74 verify(w, times(1)).onComplete();
75 }
76
77 @Test
78 public void distinctUntilChangedOfNormalSource() {
79 Observable<String> src = Observable.just("a", "b", "c", "c", "c", "b", "b", "a", "e");
80 src.distinctUntilChanged().subscribe(w);
81
82 InOrder inOrder = inOrder(w);
83 inOrder.verify(w, times(1)).onNext("a");
84 inOrder.verify(w, times(1)).onNext("b");
85 inOrder.verify(w, times(1)).onNext("c");
86 inOrder.verify(w, times(1)).onNext("b");
87 inOrder.verify(w, times(1)).onNext("a");
88 inOrder.verify(w, times(1)).onNext("e");
89 inOrder.verify(w, times(1)).onComplete();
90 inOrder.verify(w, never()).onNext(anyString());
91 verify(w, never()).onError(any(Throwable.class));
92 }
93
94 @Test
95 public void distinctUntilChangedOfNormalSourceWithKeySelector() {
96 Observable<String> src = Observable.just("a", "b", "c", "C", "c", "B", "b", "a", "e");
97 src.distinctUntilChanged(TO_UPPER_WITH_EXCEPTION).subscribe(w);
98
99 InOrder inOrder = inOrder(w);
100 inOrder.verify(w, times(1)).onNext("a");
101 inOrder.verify(w, times(1)).onNext("b");
102 inOrder.verify(w, times(1)).onNext("c");
103 inOrder.verify(w, times(1)).onNext("B");
104 inOrder.verify(w, times(1)).onNext("a");
105 inOrder.verify(w, times(1)).onNext("e");
106 inOrder.verify(w, times(1)).onComplete();
107 inOrder.verify(w, never()).onNext(anyString());
108 verify(w, never()).onError(any(Throwable.class));
109 }
110
111 @Test
112 public void customComparator() {
113 Observable<String> source = Observable.just("a", "b", "B", "A", "a", "C");
114
115 TestObserver<String> to = TestObserver.create();
116
117 source.distinctUntilChanged(new BiPredicate<String, String>() {
118 @Override
119 public boolean test(String a, String b) {
120 return a.compareToIgnoreCase(b) == 0;
121 }
122 })
123 .subscribe(to);
124
125 to.assertValues("a", "b", "A", "C");
126 to.assertNoErrors();
127 to.assertComplete();
128 }
129
130 @Test
131 public void customComparatorThrows() {
132 Observable<String> source = Observable.just("a", "b", "B", "A", "a", "C");
133
134 TestObserver<String> to = TestObserver.create();
135
136 source.distinctUntilChanged(new BiPredicate<String, String>() {
137 @Override
138 public boolean test(String a, String b) {
139 throw new TestException();
140 }
141 })
142 .subscribe(to);
143
144 to.assertValue("a");
145 to.assertNotComplete();
146 to.assertError(TestException.class);
147 }
148
149 @Test
150 public void fused() {
151 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
152
153 Observable.just(1, 2, 2, 3, 3, 4, 5)
154 .distinctUntilChanged(new BiPredicate<Integer, Integer>() {
155 @Override
156 public boolean test(Integer a, Integer b) throws Exception {
157 return a.equals(b);
158 }
159 })
160 .subscribe(to);
161
162 to.assertFuseable()
163 .assertFusionMode(QueueFuseable.SYNC)
164 .assertResult(1, 2, 3, 4, 5)
165 ;
166 }
167
168 @Test
169 public void fusedAsync() {
170 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
171
172 UnicastSubject<Integer> us = UnicastSubject.create();
173
174 us
175 .distinctUntilChanged(new BiPredicate<Integer, Integer>() {
176 @Override
177 public boolean test(Integer a, Integer b) throws Exception {
178 return a.equals(b);
179 }
180 })
181 .subscribe(to);
182
183 TestHelper.emit(us, 1, 2, 2, 3, 3, 4, 5);
184
185 to.assertFuseable()
186 .assertFusionMode(QueueFuseable.ASYNC)
187 .assertResult(1, 2, 3, 4, 5)
188 ;
189 }
190
191 @Test
192 public void ignoreCancel() {
193 List<Throwable> errors = TestHelper.trackPluginErrors();
194
195 try {
196 Observable.wrap(new ObservableSource<Integer>() {
197 @Override
198 public void subscribe(Observer<? super Integer> observer) {
199 observer.onSubscribe(Disposable.empty());
200 observer.onNext(1);
201 observer.onNext(2);
202 observer.onNext(3);
203 observer.onError(new IOException());
204 observer.onComplete();
205 }
206 })
207 .distinctUntilChanged(new BiPredicate<Integer, Integer>() {
208 @Override
209 public boolean test(Integer a, Integer b) throws Exception {
210 throw new TestException();
211 }
212 })
213 .test()
214 .assertFailure(TestException.class, 1);
215
216 TestHelper.assertUndeliverable(errors, 0, IOException.class);
217 } finally {
218 RxJavaPlugins.reset();
219 }
220 }
221
222 class Mutable {
223 int value;
224 }
225
226 @Test
227 public void mutableWithSelector() {
228 Mutable m = new Mutable();
229
230 PublishSubject<Mutable> ps = PublishSubject.create();
231
232 TestObserver<Mutable> to = ps.distinctUntilChanged(new Function<Mutable, Object>() {
233 @Override
234 public Object apply(Mutable m) throws Exception {
235 return m.value;
236 }
237 })
238 .test();
239
240 ps.onNext(m);
241 m.value = 1;
242 ps.onNext(m);
243 ps.onComplete();
244
245 to.assertResult(m, m);
246 }
247 }