Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTimedTest.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.flowable;
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 import org.reactivestreams.*;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.exceptions.TestException;
27 import io.reactivex.rxjava3.functions.Function;
28 import io.reactivex.rxjava3.processors.PublishProcessor;
29 import io.reactivex.rxjava3.schedulers.*;
30 import io.reactivex.rxjava3.subscribers.TestSubscriber;
31 import io.reactivex.rxjava3.testsupport.*;
32
33 public class FlowableTakeLastTimedTest extends RxJavaTest {
34
35 @Test(expected = IllegalArgumentException.class)
36 public void takeLastTimedWithNegativeCount() {
37 Flowable.just("one").takeLast(-1, 1, TimeUnit.SECONDS);
38 }
39
40 @Test
41 public void takeLastTimed() {
42 TestScheduler scheduler = new TestScheduler();
43
44 PublishProcessor<Object> source = PublishProcessor.create();
45
46 // FIXME time unit now matters!
47 Flowable<Object> result = source.takeLast(1000, TimeUnit.MILLISECONDS, scheduler);
48
49 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
50
51 InOrder inOrder = inOrder(subscriber);
52
53 result.subscribe(subscriber);
54
55 source.onNext(1); // T: 0ms
56 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
57 source.onNext(2); // T: 250ms
58 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
59 source.onNext(3); // T: 500ms
60 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
61 source.onNext(4); // T: 750ms
62 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
63 source.onNext(5); // T: 1000ms
64 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
65 source.onComplete(); // T: 1250ms
66
67 inOrder.verify(subscriber, times(1)).onNext(2);
68 inOrder.verify(subscriber, times(1)).onNext(3);
69 inOrder.verify(subscriber, times(1)).onNext(4);
70 inOrder.verify(subscriber, times(1)).onNext(5);
71 inOrder.verify(subscriber, times(1)).onComplete();
72
73 verify(subscriber, never()).onError(any(Throwable.class));
74 }
75
76 @Test
77 public void takeLastTimedDelayCompletion() {
78 TestScheduler scheduler = new TestScheduler();
79
80 PublishProcessor<Object> source = PublishProcessor.create();
81
82 // FIXME time unit now matters
83 Flowable<Object> result = source.takeLast(1000, TimeUnit.MILLISECONDS, scheduler);
84
85 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
86
87 InOrder inOrder = inOrder(subscriber);
88
89 result.subscribe(subscriber);
90
91 source.onNext(1); // T: 0ms
92 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
93 source.onNext(2); // T: 250ms
94 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
95 source.onNext(3); // T: 500ms
96 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
97 source.onNext(4); // T: 750ms
98 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
99 source.onNext(5); // T: 1000ms
100 scheduler.advanceTimeBy(1250, TimeUnit.MILLISECONDS);
101 source.onComplete(); // T: 2250ms
102
103 inOrder.verify(subscriber, times(1)).onComplete();
104
105 verify(subscriber, never()).onNext(any());
106 verify(subscriber, never()).onError(any(Throwable.class));
107 }
108
109 @Test
110 public void takeLastTimedWithCapacity() {
111 TestScheduler scheduler = new TestScheduler();
112
113 PublishProcessor<Object> source = PublishProcessor.create();
114
115 // FIXME time unit now matters!
116 Flowable<Object> result = source.takeLast(2, 1000, TimeUnit.MILLISECONDS, scheduler);
117
118 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
119
120 InOrder inOrder = inOrder(subscriber);
121
122 result.subscribe(subscriber);
123
124 source.onNext(1); // T: 0ms
125 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
126 source.onNext(2); // T: 250ms
127 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
128 source.onNext(3); // T: 500ms
129 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
130 source.onNext(4); // T: 750ms
131 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
132 source.onNext(5); // T: 1000ms
133 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
134 source.onComplete(); // T: 1250ms
135
136 inOrder.verify(subscriber, times(1)).onNext(4);
137 inOrder.verify(subscriber, times(1)).onNext(5);
138 inOrder.verify(subscriber, times(1)).onComplete();
139
140 verify(subscriber, never()).onError(any(Throwable.class));
141 }
142
143 @Test
144 public void takeLastTimedThrowingSource() {
145 TestScheduler scheduler = new TestScheduler();
146
147 PublishProcessor<Object> source = PublishProcessor.create();
148
149 Flowable<Object> result = source.takeLast(1, TimeUnit.SECONDS, scheduler);
150
151 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
152
153 InOrder inOrder = inOrder(subscriber);
154
155 result.subscribe(subscriber);
156
157 source.onNext(1); // T: 0ms
158 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
159 source.onNext(2); // T: 250ms
160 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
161 source.onNext(3); // T: 500ms
162 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
163 source.onNext(4); // T: 750ms
164 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
165 source.onNext(5); // T: 1000ms
166 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
167 source.onError(new TestException()); // T: 1250ms
168
169 inOrder.verify(subscriber, times(1)).onError(any(TestException.class));
170
171 verify(subscriber, never()).onNext(any());
172 verify(subscriber, never()).onComplete();
173 }
174
175 @Test
176 public void takeLastTimedWithZeroCapacity() {
177 TestScheduler scheduler = new TestScheduler();
178
179 PublishProcessor<Object> source = PublishProcessor.create();
180
181 Flowable<Object> result = source.takeLast(0, 1, TimeUnit.SECONDS, scheduler);
182
183 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
184
185 InOrder inOrder = inOrder(subscriber);
186
187 result.subscribe(subscriber);
188
189 source.onNext(1); // T: 0ms
190 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
191 source.onNext(2); // T: 250ms
192 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
193 source.onNext(3); // T: 500ms
194 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
195 source.onNext(4); // T: 750ms
196 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
197 source.onNext(5); // T: 1000ms
198 scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
199 source.onComplete(); // T: 1250ms
200
201 inOrder.verify(subscriber, times(1)).onComplete();
202
203 verify(subscriber, never()).onNext(any());
204 verify(subscriber, never()).onError(any(Throwable.class));
205 }
206
207 @Test
208 public void continuousDelivery() {
209 TestScheduler scheduler = new TestScheduler();
210
211 TestSubscriber<Integer> ts = new TestSubscriber<>(0L);
212
213 PublishProcessor<Integer> pp = PublishProcessor.create();
214
215 pp.takeLast(1000, TimeUnit.MILLISECONDS, scheduler).subscribe(ts);
216
217 pp.onNext(1);
218 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
219 pp.onNext(2);
220 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
221 pp.onNext(3);
222 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
223 pp.onNext(4);
224 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
225 pp.onComplete();
226 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
227
228 ts.assertNoValues();
229
230 ts.request(1);
231
232 ts.assertValue(3);
233
234 scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
235 ts.request(1);
236
237 ts.assertValues(3, 4);
238 ts.assertComplete();
239 ts.assertNoErrors();
240
241 }
242
243 @Test
244 public void takeLastTimeAndSize() {
245 Flowable.just(1, 2)
246 .takeLast(1, 1, TimeUnit.MINUTES)
247 .test()
248 .assertResult(2);
249 }
250
251 @Test
252 public void takeLastTime() {
253 Flowable.just(1, 2)
254 .takeLast(1, TimeUnit.MINUTES)
255 .test()
256 .assertResult(1, 2);
257 }
258
259 @Test
260 public void takeLastTimeDelayError() {
261 Flowable.just(1, 2).concatWith(Flowable.<Integer>error(new TestException()))
262 .takeLast(1, TimeUnit.MINUTES, true)
263 .test()
264 .assertFailure(TestException.class, 1, 2);
265 }
266
267 @Test
268 public void takeLastTimeDelayErrorCustomScheduler() {
269 Flowable.just(1, 2).concatWith(Flowable.<Integer>error(new TestException()))
270 .takeLast(1, TimeUnit.MINUTES, Schedulers.io(), true)
271 .test()
272 .assertFailure(TestException.class, 1, 2);
273 }
274
275 @Test
276 public void disposed() {
277 TestHelper.checkDisposed(PublishProcessor.create().takeLast(1, TimeUnit.MINUTES));
278 }
279
280 @Test
281 public void observeOn() {
282 Observable.range(1, 1000)
283 .takeLast(1, TimeUnit.DAYS)
284 .take(500)
285 .observeOn(Schedulers.single(), true, 1)
286 .to(TestHelper.<Integer>testConsumer())
287 .awaitDone(5, TimeUnit.SECONDS)
288 .assertSubscribed()
289 .assertValueCount(500)
290 .assertNoErrors()
291 .assertComplete();
292 }
293
294 @Test
295 public void cancelCompleteRace() {
296 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
297 final PublishProcessor<Integer> pp = PublishProcessor.create();
298
299 final TestSubscriber<Integer> ts = pp.takeLast(1, TimeUnit.DAYS).test();
300
301 Runnable r1 = new Runnable() {
302 @Override
303 public void run() {
304 pp.onComplete();
305 }
306 };
307
308 Runnable r2 = new Runnable() {
309 @Override
310 public void run() {
311 ts.cancel();
312 }
313 };
314
315 TestHelper.race(r1, r2);
316 }
317 }
318
319 @Test
320 public void emptyDelayError() {
321 Flowable.empty()
322 .takeLast(1, TimeUnit.DAYS, true)
323 .test()
324 .assertResult();
325 }
326
327 @Test
328 public void doubleOnSubscribe() {
329 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<Object>>() {
330 @Override
331 public Publisher<Object> apply(Flowable<Object> f) throws Exception {
332 return f.takeLast(1, TimeUnit.SECONDS);
333 }
334 });
335 }
336
337 @Test
338 public void badRequest() {
339 TestHelper.assertBadRequestReported(PublishProcessor.create().takeLast(1, TimeUnit.SECONDS));
340 }
341
342 @Test
343 public void lastWindowIsFixedInTime() {
344 TimesteppingScheduler scheduler = new TimesteppingScheduler();
345 scheduler.stepEnabled = false;
346
347 PublishProcessor<Integer> pp = PublishProcessor.create();
348
349 TestSubscriber<Integer> ts = pp
350 .takeLast(2, TimeUnit.SECONDS, scheduler)
351 .test();
352
353 pp.onNext(1);
354 pp.onNext(2);
355 pp.onNext(3);
356 pp.onNext(4);
357
358 scheduler.stepEnabled = true;
359
360 pp.onComplete();
361
362 ts.assertResult(1, 2, 3, 4);
363 }
364 }