blob: 0b1b8adf4953eca917effa26cf5fa87cf2a19eae [file] [log] [blame]
Ana Krulecfb772822018-11-30 10:44:07 +01001/*
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 */
Ana Krulecfb772822018-11-30 10:44:07 +010016#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
23#include "AsyncCallRecorder.h"
Ana Krulecf2c006d2019-06-21 15:37:07 -070024#include "Scheduler/OneShotTimer.h"
Ana Krulecfb772822018-11-30 10:44:07 +010025
26using namespace std::chrono_literals;
27
28namespace android {
29namespace scheduler {
30
Ana Krulecf2c006d2019-06-21 15:37:07 -070031class OneShotTimerTest : public testing::Test {
Ana Krulecfb772822018-11-30 10:44:07 +010032protected:
Ana Krulecf2c006d2019-06-21 15:37:07 -070033 OneShotTimerTest() = default;
34 ~OneShotTimerTest() override = default;
Ana Krulecfb772822018-11-30 10:44:07 +010035
Lloyd Pique1f9f1a42019-01-31 13:04:00 -080036 // This timeout should be used when a 3ms callback is expected.
37 // While the tests typically request a callback after 3ms, the scheduler
38 // does not always cooperate, at it can take significantly longer (observed
39 // 30ms).
40 static constexpr auto waitTimeForExpected3msCallback = 100ms;
41
42 // This timeout should be used when an 3ms callback is not expected.
43 // Note that there can be false-negatives if the callback happens later.
44 static constexpr auto waitTimeForUnexpected3msCallback = 6ms;
45
Ady Abrahama1a49af2019-02-07 14:36:55 -080046 AsyncCallRecorder<void (*)()> mResetTimerCallback;
Ana Krulecfb772822018-11-30 10:44:07 +010047 AsyncCallRecorder<void (*)()> mExpiredTimerCallback;
48
Ana Krulecf2c006d2019-06-21 15:37:07 -070049 std::unique_ptr<OneShotTimer> mIdleTimer;
Lloyd Pique1f9f1a42019-01-31 13:04:00 -080050
51 void clearPendingCallbacks() {
52 while (mExpiredTimerCallback.waitForCall(0us).has_value()) {
53 }
54 }
Ana Krulecfb772822018-11-30 10:44:07 +010055};
56
57namespace {
Ana Krulecf2c006d2019-06-21 15:37:07 -070058TEST_F(OneShotTimerTest, createAndDestroyTest) {
59 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(
60 3ms, [] {}, [] {});
Ana Krulecfb772822018-11-30 10:44:07 +010061}
62
Ana Krulecf2c006d2019-06-21 15:37:07 -070063TEST_F(OneShotTimerTest, startStopTest) {
64 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(30ms, mResetTimerCallback.getInvocable(),
65 mExpiredTimerCallback.getInvocable());
Lloyd Pique1f9f1a42019-01-31 13:04:00 -080066 auto startTime = std::chrono::steady_clock::now();
Ana Krulecfb772822018-11-30 10:44:07 +010067 mIdleTimer->start();
Ady Abrahama1a49af2019-02-07 14:36:55 -080068 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
Lloyd Pique1f9f1a42019-01-31 13:04:00 -080069 // The idle timer fires after 30ms, so there should be no callback within
Ady Abrahama1a49af2019-02-07 14:36:55 -080070 // 25ms (waiting for a callback for the full 30ms would be problematic).
Lloyd Pique1f9f1a42019-01-31 13:04:00 -080071 bool callbackCalled = mExpiredTimerCallback.waitForCall(25ms).has_value();
72 // Under ideal conditions there should be no event. But occasionally
73 // it is possible that the wait just prior takes more than 30ms, and
Ana Krulecf2c006d2019-06-21 15:37:07 -070074 // a callback is observed. We check the elapsed time since before the OneShotTimer
Lloyd Pique1f9f1a42019-01-31 13:04:00 -080075 // thread was started as a sanity check to not have a flakey test.
76 EXPECT_FALSE(callbackCalled && std::chrono::steady_clock::now() - startTime < 30ms);
Ady Abrahama1a49af2019-02-07 14:36:55 -080077
78 std::this_thread::sleep_for(std::chrono::milliseconds(25));
79 EXPECT_FALSE(mResetTimerCallback.waitForCall().has_value());
Ana Krulecfb772822018-11-30 10:44:07 +010080 mIdleTimer->stop();
81}
82
Lloyd Piquec60bf702021-04-27 12:53:40 -070083// TODO(b/186417847) This test is flaky. Reenable once fixed.
84TEST_F(OneShotTimerTest, DISABLED_resetTest) {
Ana Krulecf2c006d2019-06-21 15:37:07 -070085 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(20ms, mResetTimerCallback.getInvocable(),
86 mExpiredTimerCallback.getInvocable());
Ana Krulecfb772822018-11-30 10:44:07 +010087 mIdleTimer->start();
Ady Abrahama1a49af2019-02-07 14:36:55 -080088 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
Lloyd Pique1f9f1a42019-01-31 13:04:00 -080089 // Observe any event that happens in about 25ms. We don't care if one was
90 // observed or not.
91 mExpiredTimerCallback.waitForCall(25ms).has_value();
Ana Krulecfb772822018-11-30 10:44:07 +010092 mIdleTimer->reset();
Ady Abrahama1a49af2019-02-07 14:36:55 -080093 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
Lloyd Pique1f9f1a42019-01-31 13:04:00 -080094 // There may have been a race with the reset. Clear any callbacks we
95 // received right afterwards.
96 clearPendingCallbacks();
97 // A single callback should be generated after 30ms
98 EXPECT_TRUE(
99 mExpiredTimerCallback.waitForCall(waitTimeForExpected3msCallback + 30ms).has_value());
100 // After one event, it should be idle, and not generate another.
101 EXPECT_FALSE(
102 mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback * 10).has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100103 mIdleTimer->stop();
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800104 // Final quick check that no more callback were observed.
105 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(0ms).has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800106 EXPECT_FALSE(mResetTimerCallback.waitForCall(0ms).has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100107}
108
Lloyd Piquec60bf702021-04-27 12:53:40 -0700109// TODO(b/186417847) This test is flaky. Reenable once fixed.
110TEST_F(OneShotTimerTest, DISABLED_resetBackToBackTest) {
Ana Krulecf2c006d2019-06-21 15:37:07 -0700111 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(20ms, mResetTimerCallback.getInvocable(),
112 mExpiredTimerCallback.getInvocable());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800113 mIdleTimer->start();
114 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
115
116 mIdleTimer->reset();
Alec Mouridc28b372019-04-18 21:17:13 -0700117 EXPECT_FALSE(mResetTimerCallback.waitForCall(1ms).has_value());
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800118 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800119
120 mIdleTimer->reset();
Alec Mouridc28b372019-04-18 21:17:13 -0700121 EXPECT_FALSE(mResetTimerCallback.waitForCall(1ms).has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800122 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
123
124 mIdleTimer->reset();
Alec Mouridc28b372019-04-18 21:17:13 -0700125 EXPECT_FALSE(mResetTimerCallback.waitForCall(1ms).has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800126 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
127
128 mIdleTimer->reset();
Alec Mouridc28b372019-04-18 21:17:13 -0700129 EXPECT_FALSE(mResetTimerCallback.waitForCall(1ms).has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800130 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
131
132 // A single callback should be generated after 30ms
133 EXPECT_TRUE(
134 mExpiredTimerCallback.waitForCall(waitTimeForExpected3msCallback + 30ms).has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100135 mIdleTimer->stop();
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800136 // Final quick check that no more callback were observed.
137 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(0ms).has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800138 EXPECT_FALSE(mResetTimerCallback.waitForCall(0ms).has_value());
139}
140
Lloyd Piquec60bf702021-04-27 12:53:40 -0700141// TODO(b/186417847) This test is flaky. Reenable once fixed.
142TEST_F(OneShotTimerTest, DISABLED_startNotCalledTest) {
Ana Krulecf2c006d2019-06-21 15:37:07 -0700143 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
144 mExpiredTimerCallback.getInvocable());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800145 // The start hasn't happened, so the callback does not happen.
146 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
Ady Abraham51988ef2019-02-25 17:25:57 -0800147 EXPECT_FALSE(mResetTimerCallback.waitForCall().has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800148 mIdleTimer->stop();
149 // Final quick check that no more callback were observed.
150 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(0ms).has_value());
151 EXPECT_FALSE(mResetTimerCallback.waitForCall(0ms).has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100152}
153
Lloyd Piquec60bf702021-04-27 12:53:40 -0700154// TODO(b/186417847) This test is flaky. Reenable once fixed.
155TEST_F(OneShotTimerTest, DISABLED_idleTimerIdlesTest) {
Ana Krulecf2c006d2019-06-21 15:37:07 -0700156 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
157 mExpiredTimerCallback.getInvocable());
Ana Krulecfb772822018-11-30 10:44:07 +0100158 mIdleTimer->start();
Ady Abrahama1a49af2019-02-07 14:36:55 -0800159 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
160
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800161 // A callback should be generated after 3ms
162 EXPECT_TRUE(mExpiredTimerCallback.waitForCall(waitTimeForExpected3msCallback).has_value());
163 // After one event, it should be idle, and not generate another.
164 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
165 // Once reset, it should generate another
Ana Krulecfb772822018-11-30 10:44:07 +0100166 mIdleTimer->reset();
Ady Abraham51988ef2019-02-25 17:25:57 -0800167 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800168 EXPECT_TRUE(mExpiredTimerCallback.waitForCall(waitTimeForExpected3msCallback).has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100169 mIdleTimer->stop();
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800170 // Final quick check that no more callback were observed.
171 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(0ms).has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800172 EXPECT_FALSE(mResetTimerCallback.waitForCall(0ms).has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100173}
174
Lloyd Piquec60bf702021-04-27 12:53:40 -0700175// TODO(b/186417847) This test is flaky. Reenable once fixed.
176TEST_F(OneShotTimerTest, DISABLED_timeoutCallbackExecutionTest) {
Ana Krulecf2c006d2019-06-21 15:37:07 -0700177 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
178 mExpiredTimerCallback.getInvocable());
Ana Krulecfb772822018-11-30 10:44:07 +0100179 mIdleTimer->start();
Ady Abraham51988ef2019-02-25 17:25:57 -0800180 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800181 EXPECT_TRUE(mExpiredTimerCallback.waitForCall(waitTimeForExpected3msCallback).has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100182 mIdleTimer->stop();
183}
184
Ana Krulecf2c006d2019-06-21 15:37:07 -0700185TEST_F(OneShotTimerTest, noCallbacksAfterStopAndResetTest) {
186 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
187 mExpiredTimerCallback.getInvocable());
Ana Krulecfb772822018-11-30 10:44:07 +0100188 mIdleTimer->start();
Ady Abraham51988ef2019-02-25 17:25:57 -0800189 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800190 EXPECT_TRUE(mExpiredTimerCallback.waitForCall(waitTimeForExpected3msCallback).has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800191
Ana Krulecfb772822018-11-30 10:44:07 +0100192 mIdleTimer->stop();
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800193 clearPendingCallbacks();
Ana Krulecfb772822018-11-30 10:44:07 +0100194 mIdleTimer->reset();
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800195 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
Ady Abraham51988ef2019-02-25 17:25:57 -0800196 EXPECT_FALSE(mResetTimerCallback.waitForCall().has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100197}
198
Ana Krulecf2c006d2019-06-21 15:37:07 -0700199TEST_F(OneShotTimerTest, noCallbacksAfterStopTest) {
200 mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
201 mExpiredTimerCallback.getInvocable());
Ana Krulecfb772822018-11-30 10:44:07 +0100202 mIdleTimer->start();
Ady Abraham51988ef2019-02-25 17:25:57 -0800203 EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
Ady Abrahama1a49af2019-02-07 14:36:55 -0800204
Ana Krulecfb772822018-11-30 10:44:07 +0100205 mIdleTimer->stop();
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800206 clearPendingCallbacks();
207 mIdleTimer->reset();
Ady Abrahama1a49af2019-02-07 14:36:55 -0800208
Lloyd Pique1f9f1a42019-01-31 13:04:00 -0800209 // No more idle events should be observed
210 EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
Ady Abraham51988ef2019-02-25 17:25:57 -0800211 EXPECT_FALSE(mResetTimerCallback.waitForCall().has_value());
Ana Krulecfb772822018-11-30 10:44:07 +0100212}
213
214} // namespace
215} // namespace scheduler
Ady Abrahama1a49af2019-02-07 14:36:55 -0800216} // namespace android