1 /*
2  * Copyright 2018 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #undef LOG_TAG
17 #define LOG_TAG "SchedulerUnittests"
18 
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21 #include <utils/Log.h>
22 #include <utils/Timers.h>
23 
24 #include "AsyncCallRecorder.h"
25 #include "Scheduler/OneShotTimer.h"
26 #include "fake/FakeClock.h"
27 
28 using namespace std::chrono_literals;
29 
30 namespace android {
31 namespace scheduler {
32 
33 class OneShotTimerTest : public testing::Test {
34 protected:
35     OneShotTimerTest() = default;
36     ~OneShotTimerTest() override = default;
37 
38     AsyncCallRecorder<void (*)()> mResetTimerCallback;
39     AsyncCallRecorder<void (*)()> mExpiredTimerCallback;
40 
41     std::unique_ptr<OneShotTimer> mIdleTimer;
42 
clearPendingCallbacks()43     void clearPendingCallbacks() {
44         while (mExpiredTimerCallback.waitForCall(0us).has_value()) {
45         }
46     }
47 };
48 
49 namespace {
TEST_F(OneShotTimerTest,createAndDestroyTest)50 TEST_F(OneShotTimerTest, createAndDestroyTest) {
51     fake::FakeClock* clock = new fake::FakeClock();
52     mIdleTimer = std::make_unique<scheduler::OneShotTimer>(
53             "TestTimer", 3ms, [] {}, [] {}, std::unique_ptr<fake::FakeClock>(clock));
54 }
55 
TEST_F(OneShotTimerTest,startStopTest)56 TEST_F(OneShotTimerTest, startStopTest) {
57     fake::FakeClock* clock = new fake::FakeClock();
58     mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms,
59                                                            mResetTimerCallback.getInvocable(),
60                                                            mExpiredTimerCallback.getInvocable(),
61                                                            std::unique_ptr<fake::FakeClock>(clock));
62     mIdleTimer->start();
63     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
64     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
65 
66     clock->advanceTime(2ms);
67     EXPECT_TRUE(mExpiredTimerCallback.waitForCall().has_value());
68 
69     clock->advanceTime(2ms);
70     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
71     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
72     mIdleTimer->stop();
73 }
74 
TEST_F(OneShotTimerTest,resetTest)75 TEST_F(OneShotTimerTest, resetTest) {
76     fake::FakeClock* clock = new fake::FakeClock();
77     mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms,
78                                                            mResetTimerCallback.getInvocable(),
79                                                            mExpiredTimerCallback.getInvocable(),
80                                                            std::unique_ptr<fake::FakeClock>(clock));
81 
82     mIdleTimer->start();
83     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
84     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
85     clock->advanceTime(2ms);
86     EXPECT_TRUE(mExpiredTimerCallback.waitForCall().has_value());
87     mIdleTimer->reset();
88     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
89     clock->advanceTime(2ms);
90     EXPECT_TRUE(mExpiredTimerCallback.waitForCall().has_value());
91 
92     clock->advanceTime(2ms);
93     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
94     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
95 }
96 
TEST_F(OneShotTimerTest,resetBackToBackTest)97 TEST_F(OneShotTimerTest, resetBackToBackTest) {
98     fake::FakeClock* clock = new fake::FakeClock();
99     mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms,
100                                                            mResetTimerCallback.getInvocable(),
101                                                            mExpiredTimerCallback.getInvocable(),
102                                                            std::unique_ptr<fake::FakeClock>(clock));
103     mIdleTimer->start();
104     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
105 
106     mIdleTimer->reset();
107     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
108     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
109 
110     mIdleTimer->reset();
111     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
112     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
113 
114     mIdleTimer->reset();
115     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
116     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
117 
118     mIdleTimer->reset();
119     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
120 
121     clock->advanceTime(2ms);
122     EXPECT_TRUE(mExpiredTimerCallback.waitForCall().has_value());
123 
124     mIdleTimer->stop();
125     clock->advanceTime(2ms);
126     // Final quick check that no more callback were observed.
127     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
128     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
129 }
130 
TEST_F(OneShotTimerTest,startNotCalledTest)131 TEST_F(OneShotTimerTest, startNotCalledTest) {
132     fake::FakeClock* clock = new fake::FakeClock();
133     mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms,
134                                                            mResetTimerCallback.getInvocable(),
135                                                            mExpiredTimerCallback.getInvocable(),
136                                                            std::unique_ptr<fake::FakeClock>(clock));
137     // The start hasn't happened, so the callback does not happen.
138     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
139     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
140     mIdleTimer->stop();
141     clock->advanceTime(2ms);
142     // Final quick check that no more callback were observed.
143     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
144     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
145 }
146 
TEST_F(OneShotTimerTest,idleTimerIdlesTest)147 TEST_F(OneShotTimerTest, idleTimerIdlesTest) {
148     fake::FakeClock* clock = new fake::FakeClock();
149     mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms,
150                                                            mResetTimerCallback.getInvocable(),
151                                                            mExpiredTimerCallback.getInvocable(),
152                                                            std::unique_ptr<fake::FakeClock>(clock));
153     mIdleTimer->start();
154     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
155     clock->advanceTime(2ms);
156     EXPECT_TRUE(mExpiredTimerCallback.waitForCall().has_value());
157 
158     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
159     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
160 
161     mIdleTimer->reset();
162     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
163     clock->advanceTime(2ms);
164     EXPECT_TRUE(mExpiredTimerCallback.waitForCall().has_value());
165     mIdleTimer->stop();
166     clock->advanceTime(2ms);
167     // Final quick check that no more callback were observed.
168     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
169     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
170 }
171 
TEST_F(OneShotTimerTest,timeoutCallbackExecutionTest)172 TEST_F(OneShotTimerTest, timeoutCallbackExecutionTest) {
173     fake::FakeClock* clock = new fake::FakeClock();
174     mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms,
175                                                            mResetTimerCallback.getInvocable(),
176                                                            mExpiredTimerCallback.getInvocable(),
177                                                            std::unique_ptr<fake::FakeClock>(clock));
178     mIdleTimer->start();
179     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
180 
181     clock->advanceTime(2ms);
182     EXPECT_TRUE(mExpiredTimerCallback.waitForCall().has_value());
183     mIdleTimer->stop();
184     clock->advanceTime(2ms);
185     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
186     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
187 }
188 
TEST_F(OneShotTimerTest,noCallbacksAfterStopAndResetTest)189 TEST_F(OneShotTimerTest, noCallbacksAfterStopAndResetTest) {
190     fake::FakeClock* clock = new fake::FakeClock();
191     mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms,
192                                                            mResetTimerCallback.getInvocable(),
193                                                            mExpiredTimerCallback.getInvocable(),
194                                                            std::unique_ptr<fake::FakeClock>(clock));
195     mIdleTimer->start();
196     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
197     clock->advanceTime(2ms);
198     EXPECT_TRUE(mExpiredTimerCallback.waitForCall().has_value());
199 
200     mIdleTimer->stop();
201     mIdleTimer->reset();
202     clock->advanceTime(2ms);
203     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
204     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
205 }
206 
TEST_F(OneShotTimerTest,noCallbacksAfterStopTest)207 TEST_F(OneShotTimerTest, noCallbacksAfterStopTest) {
208     fake::FakeClock* clock = new fake::FakeClock();
209     mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms,
210                                                            mResetTimerCallback.getInvocable(),
211                                                            mExpiredTimerCallback.getInvocable(),
212                                                            std::unique_ptr<fake::FakeClock>(clock));
213     mIdleTimer->start();
214     EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
215     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
216 
217     mIdleTimer->stop();
218     mIdleTimer->reset();
219 
220     clock->advanceTime(2ms);
221     // No more idle events should be observed
222     EXPECT_FALSE(mExpiredTimerCallback.waitForUnexpectedCall().has_value());
223     EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value());
224 }
225 
226 } // namespace
227 } // namespace scheduler
228 } // namespace android
229