Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTimestampTest.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.*;
22 import org.mockito.InOrder;
23 import org.reactivestreams.Subscriber;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.functions.Function;
27 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
28 import io.reactivex.rxjava3.processors.PublishProcessor;
29 import io.reactivex.rxjava3.schedulers.*;
30 import io.reactivex.rxjava3.testsupport.TestHelper;
31
32 public class FlowableTimestampTest extends RxJavaTest {
33 Subscriber<Object> subscriber;
34
35 @Before
36 public void before() {
37 subscriber = TestHelper.mockSubscriber();
38 }
39
40 @Test
41 public void timestampWithScheduler() {
42 TestScheduler scheduler = new TestScheduler();
43
44 PublishProcessor<Integer> source = PublishProcessor.create();
45 Flowable<Timed<Integer>> m = source.timestamp(scheduler);
46 m.subscribe(subscriber);
47
48 source.onNext(1);
49 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
50 source.onNext(2);
51 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
52 source.onNext(3);
53
54 InOrder inOrder = inOrder(subscriber);
55
56 inOrder.verify(subscriber, times(1)).onNext(new Timed<>(1, 0, TimeUnit.MILLISECONDS));
57 inOrder.verify(subscriber, times(1)).onNext(new Timed<>(2, 100, TimeUnit.MILLISECONDS));
58 inOrder.verify(subscriber, times(1)).onNext(new Timed<>(3, 200, TimeUnit.MILLISECONDS));
59
60 verify(subscriber, never()).onError(any(Throwable.class));
61 verify(subscriber, never()).onComplete();
62 }
63
64 @Test
65 public void timestampWithScheduler2() {
66 TestScheduler scheduler = new TestScheduler();
67
68 PublishProcessor<Integer> source = PublishProcessor.create();
69 Flowable<Timed<Integer>> m = source.timestamp(scheduler);
70 m.subscribe(subscriber);
71
72 source.onNext(1);
73 source.onNext(2);
74 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
75 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
76 source.onNext(3);
77
78 InOrder inOrder = inOrder(subscriber);
79
80 inOrder.verify(subscriber, times(1)).onNext(new Timed<>(1, 0, TimeUnit.MILLISECONDS));
81 inOrder.verify(subscriber, times(1)).onNext(new Timed<>(2, 0, TimeUnit.MILLISECONDS));
82 inOrder.verify(subscriber, times(1)).onNext(new Timed<>(3, 200, TimeUnit.MILLISECONDS));
83
84 verify(subscriber, never()).onError(any(Throwable.class));
85 verify(subscriber, never()).onComplete();
86 }
87
88 @Test
89 public void timeIntervalDefault() {
90 final TestScheduler scheduler = new TestScheduler();
91
92 RxJavaPlugins.setComputationSchedulerHandler(new Function<Scheduler, Scheduler>() {
93 @Override
94 public Scheduler apply(Scheduler v) throws Exception {
95 return scheduler;
96 }
97 });
98
99 try {
100 Flowable.range(1, 5)
101 .timestamp()
102 .map(new Function<Timed<Integer>, Long>() {
103 @Override
104 public Long apply(Timed<Integer> v) throws Exception {
105 return v.time();
106 }
107 })
108 .test()
109 .assertResult(0L, 0L, 0L, 0L, 0L);
110 } finally {
111 RxJavaPlugins.reset();
112 }
113 }
114
115 @Test
116 public void timeIntervalDefaultSchedulerCustomUnit() {
117 final TestScheduler scheduler = new TestScheduler();
118
119 RxJavaPlugins.setComputationSchedulerHandler(new Function<Scheduler, Scheduler>() {
120 @Override
121 public Scheduler apply(Scheduler v) throws Exception {
122 return scheduler;
123 }
124 });
125
126 try {
127 Flowable.range(1, 5)
128 .timestamp(TimeUnit.SECONDS)
129 .map(new Function<Timed<Integer>, Long>() {
130 @Override
131 public Long apply(Timed<Integer> v) throws Exception {
132 return v.time();
133 }
134 })
135 .test()
136 .assertResult(0L, 0L, 0L, 0L, 0L);
137 } finally {
138 RxJavaPlugins.reset();
139 }
140 }
141
142 }