Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTimedTest.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.any;
17 import static org.mockito.Mockito.*;
18
19 import java.util.concurrent.TimeUnit;
20
21 import org.junit.Test;
22 import org.mockito.InOrder;
23
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.exceptions.TestException;
26 import io.reactivex.rxjava3.observers.TestObserver;
27 import io.reactivex.rxjava3.schedulers.*;
28 import io.reactivex.rxjava3.subjects.PublishSubject;
29 import io.reactivex.rxjava3.testsupport.*;
30
31 public class ObservableTakeLastTimedTest extends RxJavaTest {
32
33 @Test(expected = IllegalArgumentException.class)
34 public void takeLastTimedWithNegativeCount() {
35 Observable.just("one").takeLast(-1, 1, TimeUnit.SECONDS);
36 }
37
38 @Test
39 public void takeLastTimed() {
40 TestScheduler scheduler = new TestScheduler();
41
42 PublishSubject<Object> source = PublishSubject.create();
43
44 // FIXME time unit now matters!
45 Observable<Object> result = source.takeLast(1000, TimeUnit.MILLISECONDS, scheduler);
46
47 Observer<Object> o = TestHelper.mockObserver();
48
49 InOrder inOrder = inOrder(o);
50
51 result.subscribe(o);
52
53 source.onNext(1); // T: 0ms
54 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
55 source.onNext(2); // T: 250ms
56 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
57 source.onNext(3); // T: 500ms
58 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
59 source.onNext(4); // T: 750ms
60 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
61 source.onNext(5); // T: 1000ms
62 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
63 source.onComplete(); // T: 1250ms
64
65 inOrder.verify(o, times(1)).onNext(2);
66 inOrder.verify(o, times(1)).onNext(3);
67 inOrder.verify(o, times(1)).onNext(4);
68 inOrder.verify(o, times(1)).onNext(5);
69 inOrder.verify(o, times(1)).onComplete();
70
71 verify(o, never()).onError(any(Throwable.class));
72 }
73
74 @Test
75 public void takeLastTimedDelayCompletion() {
76 TestScheduler scheduler = new TestScheduler();
77
78 PublishSubject<Object> source = PublishSubject.create();
79
80 // FIXME time unit now matters
81 Observable<Object> result = source.takeLast(1000, TimeUnit.MILLISECONDS, scheduler);
82
83 Observer<Object> o = TestHelper.mockObserver();
84
85 InOrder inOrder = inOrder(o);
86
87 result.subscribe(o);
88
89 source.onNext(1); // T: 0ms
90 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
91 source.onNext(2); // T: 250ms
92 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
93 source.onNext(3); // T: 500ms
94 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
95 source.onNext(4); // T: 750ms
96 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
97 source.onNext(5); // T: 1000ms
98 scheduler.advanceTimeBy(1250, TimeUnit.MILLISECONDS);
99 source.onComplete(); // T: 2250ms
100
101 inOrder.verify(o, times(1)).onComplete();
102
103 verify(o, never()).onNext(any());
104 verify(o, never()).onError(any(Throwable.class));
105 }
106
107 @Test
108 public void takeLastTimedWithCapacity() {
109 TestScheduler scheduler = new TestScheduler();
110
111 PublishSubject<Object> source = PublishSubject.create();
112
113 // FIXME time unit now matters!
114 Observable<Object> result = source.takeLast(2, 1000, TimeUnit.MILLISECONDS, scheduler);
115
116 Observer<Object> o = TestHelper.mockObserver();
117
118 InOrder inOrder = inOrder(o);
119
120 result.subscribe(o);
121
122 source.onNext(1); // T: 0ms
123 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
124 source.onNext(2); // T: 250ms
125 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
126 source.onNext(3); // T: 500ms
127 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
128 source.onNext(4); // T: 750ms
129 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
130 source.onNext(5); // T: 1000ms
131 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
132 source.onComplete(); // T: 1250ms
133
134 inOrder.verify(o, times(1)).onNext(4);
135 inOrder.verify(o, times(1)).onNext(5);
136 inOrder.verify(o, times(1)).onComplete();
137
138 verify(o, never()).onError(any(Throwable.class));
139 }
140
141 @Test
142 public void takeLastTimedThrowingSource() {
143 TestScheduler scheduler = new TestScheduler();
144
145 PublishSubject<Object> source = PublishSubject.create();
146
147 Observable<Object> result = source.takeLast(1, TimeUnit.SECONDS, scheduler);
148
149 Observer<Object> o = TestHelper.mockObserver();
150
151 InOrder inOrder = inOrder(o);
152
153 result.subscribe(o);
154
155 source.onNext(1); // T: 0ms
156 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
157 source.onNext(2); // T: 250ms
158 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
159 source.onNext(3); // T: 500ms
160 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
161 source.onNext(4); // T: 750ms
162 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
163 source.onNext(5); // T: 1000ms
164 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
165 source.onError(new TestException()); // T: 1250ms
166
167 inOrder.verify(o, times(1)).onError(any(TestException.class));
168
169 verify(o, never()).onNext(any());
170 verify(o, never()).onComplete();
171 }
172
173 @Test
174 public void takeLastTimedWithZeroCapacity() {
175 TestScheduler scheduler = new TestScheduler();
176
177 PublishSubject<Object> source = PublishSubject.create();
178
179 Observable<Object> result = source.takeLast(0, 1, TimeUnit.SECONDS, scheduler);
180
181 Observer<Object> o = TestHelper.mockObserver();
182
183 InOrder inOrder = inOrder(o);
184
185 result.subscribe(o);
186
187 source.onNext(1); // T: 0ms
188 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
189 source.onNext(2); // T: 250ms
190 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
191 source.onNext(3); // T: 500ms
192 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
193 source.onNext(4); // T: 750ms
194 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
195 source.onNext(5); // T: 1000ms
196 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
197 source.onComplete(); // T: 1250ms
198
199 inOrder.verify(o, times(1)).onComplete();
200
201 verify(o, never()).onNext(any());
202 verify(o, never()).onError(any(Throwable.class));
203 }
204
205 @Test
206 public void takeLastTimeAndSize() {
207 Observable.just(1, 2)
208 .takeLast(1, 1, TimeUnit.MINUTES)
209 .test()
210 .assertResult(2);
211 }
212
213 @Test
214 public void takeLastTime() {
215 Observable.just(1, 2)
216 .takeLast(1, TimeUnit.MINUTES)
217 .test()
218 .assertResult(1, 2);
219 }
220
221 @Test
222 public void takeLastTimeDelayError() {
223 Observable.just(1, 2).concatWith(Observable.<Integer>error(new TestException()))
224 .takeLast(1, TimeUnit.MINUTES, true)
225 .test()
226 .assertFailure(TestException.class, 1, 2);
227 }
228
229 @Test
230 public void takeLastTimeDelayErrorCustomScheduler() {
231 Observable.just(1, 2).concatWith(Observable.<Integer>error(new TestException()))
232 .takeLast(1, TimeUnit.MINUTES, Schedulers.io(), true)
233 .test()
234 .assertFailure(TestException.class, 1, 2);
235 }
236
237 @Test
238 public void disposed() {
239 TestHelper.checkDisposed(PublishSubject.create().takeLast(1, TimeUnit.MINUTES));
240 }
241
242 @Test
243 public void observeOn() {
244 Observable.range(1, 1000)
245 .takeLast(1, TimeUnit.DAYS)
246 .take(500)
247 .observeOn(Schedulers.single(), true, 1)
248 .to(TestHelper.<Integer>testConsumer())
249 .awaitDone(5, TimeUnit.SECONDS)
250 .assertSubscribed()
251 .assertValueCount(500)
252 .assertNoErrors()
253 .assertComplete();
254 }
255
256 @Test
257 public void cancelCompleteRace() {
258 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
259 final PublishSubject<Integer> ps = PublishSubject.create();
260
261 final TestObserver<Integer> to = ps.takeLast(1, TimeUnit.DAYS).test();
262
263 Runnable r1 = new Runnable() {
264 @Override
265 public void run() {
266 ps.onComplete();
267 }
268 };
269
270 Runnable r2 = new Runnable() {
271 @Override
272 public void run() {
273 to.dispose();
274 }
275 };
276
277 TestHelper.race(r1, r2);
278 }
279 }
280
281 @Test
282 public void lastWindowIsFixedInTime() {
283 TimesteppingScheduler scheduler = new TimesteppingScheduler();
284 scheduler.stepEnabled = false;
285
286 PublishSubject<Integer> ps = PublishSubject.create();
287
288 TestObserver<Integer> to = ps
289 .takeLast(2, TimeUnit.SECONDS, scheduler)
290 .test();
291
292 ps.onNext(1);
293 ps.onNext(2);
294 ps.onNext(3);
295 ps.onNext(4);
296
297 scheduler.stepEnabled = true;
298
299 ps.onComplete();
300
301 to.assertResult(1, 2, 3, 4);
302 }
303
304 @Test
305 public void doubleOnSubscribe() {
306 TestHelper.checkDoubleOnSubscribeObservable(o -> o.takeLast(1, TimeUnit.SECONDS));
307 }
308 }