SF: Set up libscheduler and libscheduler_test
Fix up dependencies to migrate Timer files for starters.
Bug: 185535769
Test: libscheduler_test
Change-Id: I028cb04f2e355e2096be9efe3c1a80f0dfd75602
diff --git a/services/surfaceflinger/Scheduler/Android.bp b/services/surfaceflinger/Scheduler/Android.bp
index 409d098..5de796d 100644
--- a/services/surfaceflinger/Scheduler/Android.bp
+++ b/services/surfaceflinger/Scheduler/Android.bp
@@ -16,6 +16,8 @@
],
shared_libs: [
"libbase",
+ "libcutils",
+ "liblog",
"libutils",
],
}
@@ -26,10 +28,36 @@
export_include_dirs: ["include"],
}
+// TODO(b/185535769): Remove libsurfaceflinger_unittest's dependency on AsyncCallRecorder.
+cc_library_headers {
+ name: "libscheduler_test_headers",
+ defaults: ["libscheduler_defaults"],
+ export_include_dirs: ["tests"],
+}
+
cc_library_static {
name: "libscheduler",
defaults: ["libscheduler_defaults"],
- srcs: [],
+ srcs: [
+ "src/Timer.cpp",
+ ],
local_include_dirs: ["include"],
export_include_dirs: ["include"],
}
+
+cc_test {
+ name: "libscheduler_test",
+ test_suites: ["device-tests"],
+ defaults: ["libscheduler_defaults"],
+ srcs: [
+ "tests/TimerTest.cpp",
+ ],
+ static_libs: [
+ "libgmock",
+ "libgtest",
+ "libscheduler",
+ ],
+ sanitize: {
+ address: true,
+ },
+}
diff --git a/services/surfaceflinger/Scheduler/VSyncDispatch.h b/services/surfaceflinger/Scheduler/VSyncDispatch.h
index b52706f..2bfe204 100644
--- a/services/surfaceflinger/Scheduler/VSyncDispatch.h
+++ b/services/surfaceflinger/Scheduler/VSyncDispatch.h
@@ -16,17 +16,15 @@
#pragma once
-#include <utils/Log.h>
-#include <utils/Timers.h>
#include <functional>
#include <optional>
#include <string>
+#include <utils/Timers.h>
+
#include "StrongTyping.h"
namespace android::scheduler {
-class TimeKeeper;
-class VSyncTracker;
using ScheduleResult = std::optional<nsecs_t>;
@@ -64,8 +62,7 @@
* invocation of callbackFn.
*
*/
- virtual CallbackToken registerCallback(Callback const& callbackFn,
- std::string callbackName) = 0;
+ virtual CallbackToken registerCallback(Callback, std::string callbackName) = 0;
/*
* Unregisters a callback.
@@ -142,8 +139,9 @@
protected:
VSyncDispatch() = default;
- VSyncDispatch(VSyncDispatch const&) = delete;
- VSyncDispatch& operator=(VSyncDispatch const&) = delete;
+
+ VSyncDispatch(const VSyncDispatch&) = delete;
+ VSyncDispatch& operator=(const VSyncDispatch&) = delete;
};
/*
@@ -152,11 +150,11 @@
*/
class VSyncCallbackRegistration {
public:
- VSyncCallbackRegistration(VSyncDispatch&, VSyncDispatch::Callback const& callbackFn,
- std::string const& callbackName);
+ VSyncCallbackRegistration(VSyncDispatch&, VSyncDispatch::Callback, std::string callbackName);
+ ~VSyncCallbackRegistration();
+
VSyncCallbackRegistration(VSyncCallbackRegistration&&);
VSyncCallbackRegistration& operator=(VSyncCallbackRegistration&&);
- ~VSyncCallbackRegistration();
// See documentation for VSyncDispatch::schedule.
ScheduleResult schedule(VSyncDispatch::ScheduleTiming scheduleTiming);
@@ -165,9 +163,6 @@
CancelResult cancel();
private:
- VSyncCallbackRegistration(VSyncCallbackRegistration const&) = delete;
- VSyncCallbackRegistration& operator=(VSyncCallbackRegistration const&) = delete;
-
std::reference_wrapper<VSyncDispatch> mDispatch;
VSyncDispatch::CallbackToken mToken;
bool mValidToken;
diff --git a/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp b/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp
index c0646ad..27f4311 100644
--- a/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp
+++ b/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp
@@ -22,7 +22,8 @@
#include <ftl/concat.h>
#include <utils/Trace.h>
-#include "TimeKeeper.h"
+#include <scheduler/TimeKeeper.h>
+
#include "VSyncDispatchTimerQueue.h"
#include "VSyncTracker.h"
@@ -31,6 +32,7 @@
using base::StringAppendF;
namespace {
+
nsecs_t getExpectedCallbackTime(nsecs_t nextVsyncTime,
const VSyncDispatch::ScheduleTiming& timing) {
return nextVsyncTime - timing.readyDuration - timing.workDuration;
@@ -42,17 +44,17 @@
std::max(timing.earliestVsync, now + timing.workDuration + timing.readyDuration));
return getExpectedCallbackTime(nextVsyncTime, timing);
}
+
} // namespace
VSyncDispatch::~VSyncDispatch() = default;
VSyncTracker::~VSyncTracker() = default;
-TimeKeeper::~TimeKeeper() = default;
-VSyncDispatchTimerQueueEntry::VSyncDispatchTimerQueueEntry(std::string const& name,
- VSyncDispatch::Callback const& cb,
+VSyncDispatchTimerQueueEntry::VSyncDispatchTimerQueueEntry(std::string name,
+ VSyncDispatch::Callback callback,
nsecs_t minVsyncDistance)
- : mName(name),
- mCallback(cb),
+ : mName(std::move(name)),
+ mCallback(std::move(callback)),
mMinVsyncDistance(minVsyncDistance) {}
std::optional<nsecs_t> VSyncDispatchTimerQueueEntry::lastExecutedVsyncTarget() const {
@@ -301,13 +303,13 @@
}
VSyncDispatchTimerQueue::CallbackToken VSyncDispatchTimerQueue::registerCallback(
- Callback const& callbackFn, std::string callbackName) {
+ Callback callback, std::string callbackName) {
std::lock_guard lock(mMutex);
return CallbackToken{
mCallbacks
.emplace(++mCallbackToken,
- std::make_shared<VSyncDispatchTimerQueueEntry>(callbackName,
- callbackFn,
+ std::make_shared<VSyncDispatchTimerQueueEntry>(std::move(callbackName),
+ std::move(callback),
mMinVsyncDistance))
.first->first};
}
@@ -402,10 +404,10 @@
}
VSyncCallbackRegistration::VSyncCallbackRegistration(VSyncDispatch& dispatch,
- VSyncDispatch::Callback const& callbackFn,
- std::string const& callbackName)
+ VSyncDispatch::Callback callback,
+ std::string callbackName)
: mDispatch(dispatch),
- mToken(dispatch.registerCallback(callbackFn, callbackName)),
+ mToken(dispatch.registerCallback(std::move(callback), std::move(callbackName))),
mValidToken(true) {}
VSyncCallbackRegistration::VSyncCallbackRegistration(VSyncCallbackRegistration&& other)
diff --git a/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h b/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h
index 76e1caf..3186d6d 100644
--- a/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h
+++ b/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h
@@ -16,7 +16,6 @@
#pragma once
-#include <android-base/thread_annotations.h>
#include <functional>
#include <memory>
#include <mutex>
@@ -24,10 +23,14 @@
#include <string_view>
#include <unordered_map>
+#include <android-base/thread_annotations.h>
+
#include "VSyncDispatch.h"
namespace android::scheduler {
+class VSyncTracker;
+
// VSyncDispatchTimerQueueEntry is a helper class representing internal state for each entry in
// VSyncDispatchTimerQueue hoisted to public for unit testing.
class VSyncDispatchTimerQueueEntry {
@@ -36,7 +39,7 @@
// Valid transition: disarmed -> armed ( when scheduled )
// Valid transition: armed -> running -> disarmed ( when timer is called)
// Valid transition: armed -> disarmed ( when cancelled )
- VSyncDispatchTimerQueueEntry(std::string const& name, VSyncDispatch::Callback const& fn,
+ VSyncDispatchTimerQueueEntry(std::string name, VSyncDispatch::Callback,
nsecs_t minVsyncDistance);
std::string_view name() const;
@@ -45,10 +48,9 @@
std::optional<nsecs_t> lastExecutedVsyncTarget() const;
// This moves the state from disarmed->armed and will calculate the wakeupTime.
- ScheduleResult schedule(VSyncDispatch::ScheduleTiming timing, VSyncTracker& tracker,
- nsecs_t now);
+ ScheduleResult schedule(VSyncDispatch::ScheduleTiming, VSyncTracker&, nsecs_t now);
// This will update armed entries with the latest vsync information. Entry remains armed.
- void update(VSyncTracker& tracker, nsecs_t now);
+ void update(VSyncTracker&, nsecs_t now);
// This will return empty if not armed, or the next calculated wakeup time if armed.
// It will not update the wakeupTime.
@@ -81,11 +83,11 @@
void dump(std::string& result) const;
private:
- std::string const mName;
- VSyncDispatch::Callback const mCallback;
+ const std::string mName;
+ const VSyncDispatch::Callback mCallback;
VSyncDispatch::ScheduleTiming mScheduleTiming;
- nsecs_t const mMinVsyncDistance;
+ const nsecs_t mMinVsyncDistance;
struct ArmingInfo {
nsecs_t mActualWakeupTime;
@@ -115,19 +117,19 @@
// should be grouped into one wakeup.
// \param[in] minVsyncDistance The minimum distance between two vsync estimates before the
// vsyncs are considered the same vsync event.
- explicit VSyncDispatchTimerQueue(std::unique_ptr<TimeKeeper> tk, VSyncTracker& tracker,
- nsecs_t timerSlack, nsecs_t minVsyncDistance);
+ VSyncDispatchTimerQueue(std::unique_ptr<TimeKeeper>, VSyncTracker&, nsecs_t timerSlack,
+ nsecs_t minVsyncDistance);
~VSyncDispatchTimerQueue();
- CallbackToken registerCallback(Callback const& callbackFn, std::string callbackName) final;
- void unregisterCallback(CallbackToken token) final;
- ScheduleResult schedule(CallbackToken token, ScheduleTiming scheduleTiming) final;
- CancelResult cancel(CallbackToken token) final;
- void dump(std::string& result) const final;
+ CallbackToken registerCallback(Callback, std::string callbackName) final;
+ void unregisterCallback(CallbackToken) final;
+ ScheduleResult schedule(CallbackToken, ScheduleTiming) final;
+ CancelResult cancel(CallbackToken) final;
+ void dump(std::string&) const final;
private:
- VSyncDispatchTimerQueue(VSyncDispatchTimerQueue const&) = delete;
- VSyncDispatchTimerQueue& operator=(VSyncDispatchTimerQueue const&) = delete;
+ VSyncDispatchTimerQueue(const VSyncDispatchTimerQueue&) = delete;
+ VSyncDispatchTimerQueue& operator=(const VSyncDispatchTimerQueue&) = delete;
using CallbackMap =
std::unordered_map<CallbackToken, std::shared_ptr<VSyncDispatchTimerQueueEntry>>;
diff --git a/services/surfaceflinger/Scheduler/VSyncReactor.cpp b/services/surfaceflinger/Scheduler/VSyncReactor.cpp
index 1c9de1c..bdcab51 100644
--- a/services/surfaceflinger/Scheduler/VSyncReactor.cpp
+++ b/services/surfaceflinger/Scheduler/VSyncReactor.cpp
@@ -18,21 +18,22 @@
#undef LOG_TAG
#define LOG_TAG "VSyncReactor"
//#define LOG_NDEBUG 0
-#include "VSyncReactor.h"
+
#include <cutils/properties.h>
#include <log/log.h>
#include <utils/Trace.h>
+
#include "../TracedOrdinal.h"
-#include "TimeKeeper.h"
#include "VSyncDispatch.h"
+#include "VSyncReactor.h"
#include "VSyncTracker.h"
namespace android::scheduler {
+
using base::StringAppendF;
VsyncController::~VsyncController() = default;
-Clock::~Clock() = default;
nsecs_t SystemClock::now() const {
return systemTime(SYSTEM_TIME_MONOTONIC);
}
diff --git a/services/surfaceflinger/Scheduler/VSyncReactor.h b/services/surfaceflinger/Scheduler/VSyncReactor.h
index a9d536b..6a1950a 100644
--- a/services/surfaceflinger/Scheduler/VSyncReactor.h
+++ b/services/surfaceflinger/Scheduler/VSyncReactor.h
@@ -16,14 +16,18 @@
#pragma once
-#include <android-base/thread_annotations.h>
-#include <ui/FenceTime.h>
#include <memory>
#include <mutex>
#include <unordered_map>
#include <vector>
-#include "TimeKeeper.h"
+
+#include <android-base/thread_annotations.h>
+#include <ui/FenceTime.h>
+
+#include <scheduler/TimeKeeper.h>
+
#include "VsyncController.h"
+
namespace android::scheduler {
class Clock;
diff --git a/services/surfaceflinger/Scheduler/VsyncSchedule.cpp b/services/surfaceflinger/Scheduler/VsyncSchedule.cpp
index 77d1223..e611658 100644
--- a/services/surfaceflinger/Scheduler/VsyncSchedule.cpp
+++ b/services/surfaceflinger/Scheduler/VsyncSchedule.cpp
@@ -15,10 +15,10 @@
*/
#include <scheduler/Fps.h>
+#include <scheduler/Timer.h>
#include "VsyncSchedule.h"
-#include "Timer.h"
#include "VSyncDispatchTimerQueue.h"
#include "VSyncPredictor.h"
#include "VSyncReactor.h"
diff --git a/services/surfaceflinger/Scheduler/TimeKeeper.h b/services/surfaceflinger/Scheduler/include/scheduler/TimeKeeper.h
similarity index 81%
rename from services/surfaceflinger/Scheduler/TimeKeeper.h
rename to services/surfaceflinger/Scheduler/include/scheduler/TimeKeeper.h
index 40dd841..319390b 100644
--- a/services/surfaceflinger/Scheduler/TimeKeeper.h
+++ b/services/surfaceflinger/Scheduler/include/scheduler/TimeKeeper.h
@@ -16,14 +16,17 @@
#pragma once
-#include <utils/Timers.h>
#include <functional>
+#include <string>
+
+#include <utils/Timers.h>
namespace android::scheduler {
class Clock {
public:
virtual ~Clock();
+
/*
* Returns the SYSTEM_TIME_MONOTONIC, used by testing infra to stub time.
*/
@@ -31,8 +34,9 @@
protected:
Clock() = default;
- Clock(Clock const&) = delete;
- Clock& operator=(Clock const&) = delete;
+
+ Clock(const Clock&) = delete;
+ Clock& operator=(const Clock&) = delete;
};
/*
@@ -46,19 +50,20 @@
* Arms callback to fired when time is current based on CLOCK_MONOTONIC
* There is only one timer, and subsequent calls will reset the callback function and the time.
*/
- virtual void alarmAt(std::function<void()> const& callback, nsecs_t time) = 0;
+ virtual void alarmAt(std::function<void()>, nsecs_t time) = 0;
/*
* Cancels an existing pending callback
*/
virtual void alarmCancel() = 0;
- virtual void dump(std::string& result) const = 0;
+ virtual void dump(std::string&) const = 0;
protected:
- TimeKeeper(TimeKeeper const&) = delete;
- TimeKeeper& operator=(TimeKeeper const&) = delete;
TimeKeeper() = default;
+
+ TimeKeeper(const TimeKeeper&) = delete;
+ TimeKeeper& operator=(const TimeKeeper&) = delete;
};
} // namespace android::scheduler
diff --git a/services/surfaceflinger/Scheduler/Timer.h b/services/surfaceflinger/Scheduler/include/scheduler/Timer.h
similarity index 88%
rename from services/surfaceflinger/Scheduler/Timer.h
rename to services/surfaceflinger/Scheduler/include/scheduler/Timer.h
index eb65954..58ad6cb 100644
--- a/services/surfaceflinger/Scheduler/Timer.h
+++ b/services/surfaceflinger/Scheduler/include/scheduler/Timer.h
@@ -16,11 +16,14 @@
#pragma once
-#include "TimeKeeper.h"
+#include <array>
+#include <functional>
+#include <mutex>
+#include <thread>
#include <android-base/thread_annotations.h>
-#include <array>
-#include <thread>
+
+#include <scheduler/TimeKeeper.h>
namespace android::scheduler {
@@ -28,13 +31,15 @@
public:
Timer();
~Timer();
+
nsecs_t now() const final;
// NB: alarmAt and alarmCancel are threadsafe; with the last-returning function being effectual
// Most users will want to serialize thes calls so as to be aware of the timer state.
- void alarmAt(std::function<void()> const& cb, nsecs_t time) final;
+ void alarmAt(std::function<void()>, nsecs_t time) final;
void alarmCancel() final;
- void dump(std::string& result) const final;
+
+ void dump(std::string&) const final;
protected:
// For unit testing
@@ -54,7 +59,7 @@
void reset() EXCLUDES(mMutex);
void cleanup() REQUIRES(mMutex);
- void setDebugState(DebugState state) EXCLUDES(mMutex);
+ void setDebugState(DebugState) EXCLUDES(mMutex);
int mTimerFd = -1;
diff --git a/services/surfaceflinger/Scheduler/Timer.cpp b/services/surfaceflinger/Scheduler/src/Timer.cpp
similarity index 95%
rename from services/surfaceflinger/Scheduler/Timer.cpp
rename to services/surfaceflinger/Scheduler/src/Timer.cpp
index 38e277c..a4cf57f 100644
--- a/services/surfaceflinger/Scheduler/Timer.cpp
+++ b/services/surfaceflinger/Scheduler/src/Timer.cpp
@@ -16,7 +16,6 @@
#undef LOG_TAG
#define LOG_TAG "SchedulerTimer"
-#define ATRACE_TAG ATRACE_TAG_GRAPHICS
#include <chrono>
#include <cstdint>
@@ -30,12 +29,15 @@
#include <log/log.h>
#include <utils/Trace.h>
-#include "Timer.h"
+#include <scheduler/Timer.h>
namespace android::scheduler {
-static constexpr size_t kReadPipe = 0;
-static constexpr size_t kWritePipe = 1;
+constexpr size_t kReadPipe = 0;
+constexpr size_t kWritePipe = 1;
+
+Clock::~Clock() = default;
+TimeKeeper::~TimeKeeper() = default;
Timer::Timer() {
reset();
@@ -104,13 +106,13 @@
return systemTime(SYSTEM_TIME_MONOTONIC);
}
-void Timer::alarmAt(std::function<void()> const& cb, nsecs_t time) {
+void Timer::alarmAt(std::function<void()> callback, nsecs_t time) {
std::lock_guard lock(mMutex);
using namespace std::literals;
static constexpr int ns_per_s =
std::chrono::duration_cast<std::chrono::nanoseconds>(1s).count();
- mCallback = cb;
+ mCallback = std::move(callback);
mExpectingCallback = true;
struct itimerspec old_timer;
diff --git a/services/surfaceflinger/Scheduler/tests/AsyncCallRecorder.h b/services/surfaceflinger/Scheduler/tests/AsyncCallRecorder.h
new file mode 100644
index 0000000..57f0dab
--- /dev/null
+++ b/services/surfaceflinger/Scheduler/tests/AsyncCallRecorder.h
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <deque>
+#include <mutex>
+#include <optional>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <android-base/thread_annotations.h>
+
+namespace android {
+
+// This class helps record calls made by another thread when they are made
+// asynchronously, with no other way for the tests to verify that the calls have
+// been made.
+//
+// A normal Google Mock recorder, while thread safe, does not allow you to wait
+// for asynchronous calls to be made.
+//
+// Usage:
+//
+// In the test, use a Google Mock expectation to invoke an instance of the
+// recorder:
+//
+// AsyncCallRecorder<void(int)> recorder;
+//
+// EXPECT_CALL(someMock, someFunction(_)).
+// .WillRepeatedly(Invoke(recorder.getInvocable()));
+//
+// Then you can invoke the functionality being tested:
+//
+// threadUnderTest.doSomethingAsync()
+//
+// And afterwards make a number of assertions using the recorder:
+//
+// // Wait for one call (with reasonable default timeout), and get the args
+// // as a std::tuple inside a std::optional.
+// auto args = recorder.waitForCall();
+// // The returned std::optional will have a value if the recorder function
+// // was called.
+// ASSERT_TRUE(args.has_value());
+// // The arguments can be checked if needed using standard tuple
+// // operations.
+// EXPECT_EQ(123, std::get<0>(args.value()));
+//
+// Alternatively maybe you want to assert that a call was not made.
+//
+// EXPECT_FALSE(recorder.waitForUnexpectedCall().has_value());
+//
+// However this check uses a really short timeout so as not to block the test
+// unnecessarily. And it could be possible for the check to return false and
+// then the recorder could observe a call being made after.
+template <typename Func>
+class AsyncCallRecorder;
+
+template <typename... Args>
+class AsyncCallRecorder<void (*)(Args...)> {
+public:
+ // This wait value needs to be large enough to avoid flakes caused by delays
+ // scheduling threads, but small enough that tests don't take forever if
+ // something really is wrong. Based on some empirical evidence, 100ms should
+ // be enough to avoid the former.
+ static constexpr std::chrono::milliseconds DEFAULT_CALL_EXPECTED_TIMEOUT{100};
+
+ // The wait here is tricky. It's for when We don't expect to record a call,
+ // but we don't want to wait forever (or for longer than the typical test
+ // function runtime). As even the simplest Google Test can take 1ms (1000us)
+ // to run, we wait for half that time.
+ static constexpr std::chrono::microseconds UNEXPECTED_CALL_TIMEOUT{500};
+
+ using ArgTuple = std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...>;
+
+ void recordCall(Args... args) {
+ std::lock_guard<std::mutex> lock(mMutex);
+ mCalls.emplace_back(std::make_tuple(args...));
+ mCondition.notify_all();
+ }
+
+ // Returns a functor which can be used with the Google Mock Invoke()
+ // function, or as a std::function to record calls.
+ auto getInvocable() {
+ return [this](Args... args) { recordCall(args...); };
+ }
+
+ // Returns a set of arguments as a std::optional<std::tuple<...>> for the
+ // oldest call, waiting for the given timeout if necessary if there are no
+ // arguments in the FIFO.
+ std::optional<ArgTuple> waitForCall(
+ std::chrono::microseconds timeout = DEFAULT_CALL_EXPECTED_TIMEOUT)
+ NO_THREAD_SAFETY_ANALYSIS {
+ std::unique_lock<std::mutex> lock(mMutex);
+
+ // Wait if necessary for us to have a record from a call.
+ mCondition.wait_for(lock, timeout,
+ [this]() NO_THREAD_SAFETY_ANALYSIS { return !mCalls.empty(); });
+
+ // Return the arguments from the oldest call, if one was made
+ bool called = !mCalls.empty();
+ std::optional<ArgTuple> result;
+ if (called) {
+ result.emplace(std::move(mCalls.front()));
+ mCalls.pop_front();
+ }
+ return result;
+ }
+
+ // Waits using a small default timeout for when a call is not expected to be
+ // made. The returned std::optional<std:tuple<...>> should not have a value
+ // except if a set of arguments was unexpectedly received because a call was
+ // actually made.
+ //
+ // Note this function uses a small timeout to not block test execution, and
+ // it is possible the code under test could make the call AFTER the timeout
+ // expires.
+ std::optional<ArgTuple> waitForUnexpectedCall() { return waitForCall(UNEXPECTED_CALL_TIMEOUT); }
+
+private:
+ std::mutex mMutex;
+ std::condition_variable mCondition;
+ std::deque<ArgTuple> mCalls GUARDED_BY(mMutex);
+};
+
+// Like AsyncCallRecorder, but for when the function being invoked
+// asynchronously is expected to return a value.
+//
+// This helper allows a single constant return value to be set to be returned by
+// all calls that were made.
+template <typename Func>
+class AsyncCallRecorderWithCannedReturn;
+
+template <typename Ret, typename... Args>
+class AsyncCallRecorderWithCannedReturn<Ret (*)(Args...)>
+ : public AsyncCallRecorder<void (*)(Args...)> {
+public:
+ explicit AsyncCallRecorderWithCannedReturn(Ret returnvalue) : mReturnValue(returnvalue) {}
+
+ auto getInvocable() {
+ return [this](Args... args) {
+ this->recordCall(args...);
+ return mReturnValue;
+ };
+ }
+
+private:
+ const Ret mReturnValue;
+};
+
+} // namespace android
diff --git a/services/surfaceflinger/Scheduler/tests/TimerTest.cpp b/services/surfaceflinger/Scheduler/tests/TimerTest.cpp
new file mode 100644
index 0000000..47d968c
--- /dev/null
+++ b/services/surfaceflinger/Scheduler/tests/TimerTest.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <scheduler/TimeKeeper.h>
+#include <scheduler/Timer.h>
+
+#include "AsyncCallRecorder.h"
+
+namespace android::scheduler {
+
+struct TestableTimer : public Timer {
+public:
+ void makeEpollError() {
+ // close the epoll file descriptor to cause an epoll error
+ close(mEpollFd);
+ }
+};
+
+struct TimerTest : testing::Test {
+ static constexpr int kIterations = 20;
+
+ AsyncCallRecorder<void (*)()> mCallbackRecorder;
+ TestableTimer mTimer;
+
+ void timerCallback() { mCallbackRecorder.recordCall(); }
+};
+
+TEST_F(TimerTest, callsCallbackIfScheduledInPast) {
+ for (int i = 0; i < kIterations; i++) {
+ mTimer.alarmAt(std::bind(&TimerTest::timerCallback, this), systemTime() - 1'000'000);
+ EXPECT_TRUE(mCallbackRecorder.waitForCall().has_value());
+ EXPECT_FALSE(mCallbackRecorder.waitForUnexpectedCall().has_value());
+ }
+}
+
+TEST_F(TimerTest, recoversAfterEpollError) {
+ for (int i = 0; i < kIterations; i++) {
+ mTimer.makeEpollError();
+ mTimer.alarmAt(std::bind(&TimerTest::timerCallback, this), systemTime() - 1'000'000);
+ EXPECT_TRUE(mCallbackRecorder.waitForCall().has_value());
+ EXPECT_FALSE(mCallbackRecorder.waitForUnexpectedCall().has_value());
+ }
+}
+
+} // namespace android::scheduler