Merge "SF: Adding tests to Scheduler class." (8ccb5b72) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/Scheduler/Scheduler.cpp

+35 −31

Original line number	Diff line number	Diff line
		@@ -29,8 +29,15 @@

		namespace android {

		#define RETURN_VALUE_IF_INVALID(value) \
		if (handle == nullptr \|\| mConnections.count(handle->id) == 0) return value
		#define RETURN_IF_INVALID() \
		if (handle == nullptr \|\| mConnections.count(handle->id) == 0) return

		std::atomic<int64_t> Scheduler::sNextId = 0;

		Scheduler::~Scheduler() = default;

		sp<Scheduler::ConnectionHandle> Scheduler::createConnection(
		const char* connectionName, DispSync* dispSync, int64_t phaseOffsetNs,
		impl::EventThread::ResyncWithRateLimitCallback resyncCallback,
		@@ -38,11 +45,9 @@ sp<Scheduler::ConnectionHandle> Scheduler::createConnection(
		const int64_t id = sNextId++;
		ALOGV("Creating a connection handle with ID: %" PRId64 "\n", id);

		std::unique_ptr<VSyncSource> eventThreadSource =
		std::make_unique<DispSyncSource>(dispSync, phaseOffsetNs, true, connectionName);
		std::unique_ptr<EventThread> eventThread =
		std::make_unique<impl::EventThread>(std::move(eventThreadSource), resyncCallback,
		interceptCallback, connectionName);
		makeEventThread(connectionName, dispSync, phaseOffsetNs, resyncCallback,
		interceptCallback);
		auto connection = std::make_unique<Connection>(new ConnectionHandle(id),
		eventThread->createEventConnection(),
		std::move(eventThread));
		@@ -50,56 +55,55 @@ sp<Scheduler::ConnectionHandle> Scheduler::createConnection(
		return mConnections[id]->handle;
		}

		std::unique_ptr<EventThread> Scheduler::makeEventThread(
		const char* connectionName, DispSync* dispSync, int64_t phaseOffsetNs,
		impl::EventThread::ResyncWithRateLimitCallback resyncCallback,
		impl::EventThread::InterceptVSyncsCallback interceptCallback) {
		std::unique_ptr<VSyncSource> eventThreadSource =
		std::make_unique<DispSyncSource>(dispSync, phaseOffsetNs, true, connectionName);
		return std::make_unique<impl::EventThread>(std::move(eventThreadSource), resyncCallback,
		interceptCallback, connectionName);
		}

		sp<IDisplayEventConnection> Scheduler::createDisplayEventConnection(
		const sp<Scheduler::ConnectionHandle>& handle) {
		if (mConnections.count(handle->id) != 0) {
		RETURN_VALUE_IF_INVALID(nullptr);
		return mConnections[handle->id]->thread->createEventConnection();
		}
		return nullptr;
		}

		EventThread* Scheduler::getEventThread(const sp<Scheduler::ConnectionHandle>& handle) {
		if (mConnections.count(handle->id) != 0) {
		RETURN_VALUE_IF_INVALID(nullptr);
		return mConnections[handle->id]->thread.get();
		}
		return nullptr;
		}

		sp<BnDisplayEventConnection> Scheduler::getEventConnection(const sp<ConnectionHandle>& handle) {
		if (mConnections.find(handle->id) != mConnections.end()) {
		RETURN_VALUE_IF_INVALID(nullptr);
		return mConnections[handle->id]->eventConnection;
		}
		return nullptr;
		}

		void Scheduler::hotplugReceived(const sp<Scheduler::ConnectionHandle>& handle,
		EventThread::DisplayType displayType, bool connected) {
		if (mConnections.find(handle->id) != mConnections.end()) {
		RETURN_IF_INVALID();
		mConnections[handle->id]->thread->onHotplugReceived(displayType, connected);
		}
		}

		void Scheduler::onScreenAcquired(const sp<Scheduler::ConnectionHandle>& handle) {
		if (mConnections.find(handle->id) != mConnections.end()) {
		RETURN_IF_INVALID();
		mConnections[handle->id]->thread->onScreenAcquired();
		}
		}

		void Scheduler::onScreenReleased(const sp<Scheduler::ConnectionHandle>& handle) {
		if (mConnections.find(handle->id) != mConnections.end()) {
		RETURN_IF_INVALID();
		mConnections[handle->id]->thread->onScreenReleased();
		}
		}

		void Scheduler::dump(const sp<Scheduler::ConnectionHandle>& handle, String8& result) const {
		if (mConnections.find(handle->id) != mConnections.end()) {
		RETURN_IF_INVALID();
		mConnections.at(handle->id)->thread->dump(result);
		}
		}

		void Scheduler::setPhaseOffset(const sp<Scheduler::ConnectionHandle>& handle, nsecs_t phaseOffset) {
		if (mConnections.find(handle->id) != mConnections.end()) {
		RETURN_IF_INVALID();
		mConnections[handle->id]->thread->setPhaseOffset(phaseOffset);
		}
		}
		} // namespace android

services/surfaceflinger/Scheduler/Scheduler.h

+7 −1

Original line number	Diff line number	Diff line
		@@ -52,7 +52,7 @@ public:
		};

		Scheduler() = default;
		~Scheduler() = default;
		virtual ~Scheduler();

		/** Creates an EventThread connection. */
		sp<ConnectionHandle> createConnection(
		@@ -77,6 +77,12 @@ public:
		// Offers ability to modify phase offset in the event thread.
		void setPhaseOffset(const sp<ConnectionHandle>& handle, nsecs_t phaseOffset);

		protected:
		virtual std::unique_ptr<EventThread> makeEventThread(
		const char* connectionName, DispSync* dispSync, int64_t phaseOffsetNs,
		impl::EventThread::ResyncWithRateLimitCallback resyncCallback,
		impl::EventThread::InterceptVSyncsCallback interceptCallback);

		private:
		static std::atomic<int64_t> sNextId;
		std::unordered_map<int64_t, std::unique_ptr<Connection>> mConnections;

services/surfaceflinger/tests/unittests/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@ cc_test {
		"DisplayTransactionTest.cpp",
		"EventControlThreadTest.cpp",
		"EventThreadTest.cpp",
		"SchedulerTest.cpp",
		"mock/DisplayHardware/MockComposer.cpp",
		"mock/DisplayHardware/MockDisplaySurface.cpp",
		"mock/DisplayHardware/MockPowerAdvisor.cpp",

services/surfaceflinger/tests/unittests/SchedulerTest.cpp

0 → 100644

+186 −0

Original line number	Diff line number	Diff line
		#undef LOG_TAG
		#define LOG_TAG "SchedulerUnittests"

		#include <gmock/gmock.h>
		#include <gtest/gtest.h>

		#include <log/log.h>

		#include "AsyncCallRecorder.h"
		#include "Scheduler/DispSync.h"
		#include "Scheduler/EventThread.h"
		#include "Scheduler/Scheduler.h"
		#include "mock/MockDispSync.h"
		#include "mock/MockEventThread.h"

		using testing::_;
		using testing::Return;

		namespace android {

		class SchedulerTest : public testing::Test {
		protected:
		class MockEventThreadConnection : public BnDisplayEventConnection {
		public:
		MockEventThreadConnection() = default;
		~MockEventThreadConnection() = default;

		MOCK_METHOD1(stealReceiveChannel, status_t(gui::BitTube* outChannel));
		MOCK_METHOD1(setVsyncRate, status_t(uint32_t count));
		MOCK_METHOD0(requestNextVsync, void());
		};

		/**
		* This mock Scheduler class uses implementation of mock::EventThread but keeps everything else
		* the same.
		*/
		class MockScheduler : public android::Scheduler {
		public:
		MockScheduler(std::unique_ptr<EventThread> eventThread)
		: mEventThread(std::move(eventThread)) {}

		std::unique_ptr<EventThread> makeEventThread(
		const char* /* connectionName /, DispSync /* dispSync */,
		nsecs_t /* phaseOffsetNs */,
		impl::EventThread::ResyncWithRateLimitCallback /* resyncCallback */,
		impl::EventThread::InterceptVSyncsCallback /* interceptCallback */) override {
		return std::move(mEventThread);
		}

		MockScheduler() = default;
		~MockScheduler() override = default;

		std::unique_ptr<EventThread> mEventThread;
		};

		SchedulerTest();
		~SchedulerTest() override;

		sp<Scheduler::ConnectionHandle> mConnectionHandle;
		mock::DispSync* mPrimaryDispSync = new mock::DispSync();
		mock::EventThread* mEventThread;
		std::unique_ptr<MockScheduler> mScheduler;
		sp<MockEventThreadConnection> mEventThreadConnection;

		AsyncCallRecorder<void (*)()> mResyncCallRecorder;
		AsyncCallRecorder<void (*)(nsecs_t)> mInterceptVSyncCallRecorder;
		};

		SchedulerTest::SchedulerTest() {
		const ::testing::TestInfo* const test_info =
		::testing::UnitTest::GetInstance()->current_test_info();
		ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());

		std::unique_ptr<mock::EventThread> eventThread = std::make_unique<mock::EventThread>();
		mEventThread = eventThread.get();
		mScheduler = std::make_unique<MockScheduler>(std::move(eventThread));
		mEventThreadConnection = new MockEventThreadConnection();

		// createConnection call to scheduler makes a createEventConnection call to EventThread. Make
		// sure that call gets executed and returns an EventThread::Connection object.
		EXPECT_CALL(*mEventThread, createEventConnection())
		.WillRepeatedly(Return(mEventThreadConnection));

		mConnectionHandle = mScheduler->createConnection("appConnection", mPrimaryDispSync, 16,
		mResyncCallRecorder.getInvocable(),
		mInterceptVSyncCallRecorder.getInvocable());
		}

		SchedulerTest::~SchedulerTest() {
		const ::testing::TestInfo* const test_info =
		::testing::UnitTest::GetInstance()->current_test_info();
		ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
		}

		namespace {
		/* ------------------------------------------------------------------------
		* Test cases
		*/
		TEST_F(SchedulerTest, canCreateAndDestroyTest) {
		EXPECT_FALSE(mResyncCallRecorder.waitForCall().has_value());
		EXPECT_FALSE(mInterceptVSyncCallRecorder.waitForCall().has_value());
		EXPECT_EQ(0, mConnectionHandle->id);
		}

		TEST_F(SchedulerTest, testNullPtr) {
		// Passing a null pointer for ConnectionHandle is a valid argument. The code doesn't throw any
		// exceptions, just gracefully continues.
		sp<IDisplayEventConnection> returnedValue;
		ASSERT_NO_FATAL_FAILURE(returnedValue = mScheduler->createDisplayEventConnection(nullptr));
		EXPECT_TRUE(returnedValue == nullptr);
		EXPECT_TRUE(mScheduler->getEventThread(nullptr) == nullptr);
		EXPECT_TRUE(mScheduler->getEventConnection(nullptr) == nullptr);
		ASSERT_NO_FATAL_FAILURE(
		mScheduler->hotplugReceived(nullptr, EventThread::DisplayType::Primary, false));
		ASSERT_NO_FATAL_FAILURE(mScheduler->onScreenAcquired(nullptr));
		ASSERT_NO_FATAL_FAILURE(mScheduler->onScreenReleased(nullptr));
		String8 testString;
		ASSERT_NO_FATAL_FAILURE(mScheduler->dump(nullptr, testString));
		EXPECT_TRUE(testString == "");
		ASSERT_NO_FATAL_FAILURE(mScheduler->setPhaseOffset(nullptr, 10));
		}

		TEST_F(SchedulerTest, invalidConnectionHandle) {
		// Passing an invalid ConnectionHandle is a valid argument. The code doesn't throw any
		// exceptions, just gracefully continues.
		sp<Scheduler::ConnectionHandle> connectionHandle = new Scheduler::ConnectionHandle(20);

		sp<IDisplayEventConnection> returnedValue;
		ASSERT_NO_FATAL_FAILURE(returnedValue =
		mScheduler->createDisplayEventConnection(connectionHandle));
		EXPECT_TRUE(returnedValue == nullptr);
		EXPECT_TRUE(mScheduler->getEventThread(connectionHandle) == nullptr);
		EXPECT_TRUE(mScheduler->getEventConnection(connectionHandle) == nullptr);

		// The EXPECT_CALLS make sure we don't call the functions on the subsequent event threads.
		EXPECT_CALL(*mEventThread, onHotplugReceived(_, _)).Times(0);
		ASSERT_NO_FATAL_FAILURE(mScheduler->hotplugReceived(connectionHandle,
		EventThread::DisplayType::Primary, false));

		EXPECT_CALL(*mEventThread, onScreenAcquired()).Times(0);
		ASSERT_NO_FATAL_FAILURE(mScheduler->onScreenAcquired(connectionHandle));

		EXPECT_CALL(*mEventThread, onScreenReleased()).Times(0);
		ASSERT_NO_FATAL_FAILURE(mScheduler->onScreenReleased(connectionHandle));

		String8 testString;
		EXPECT_CALL(*mEventThread, dump(_)).Times(0);
		ASSERT_NO_FATAL_FAILURE(mScheduler->dump(connectionHandle, testString));
		EXPECT_TRUE(testString == "");

		EXPECT_CALL(*mEventThread, setPhaseOffset(_)).Times(0);
		ASSERT_NO_FATAL_FAILURE(mScheduler->setPhaseOffset(connectionHandle, 10));
		}

		TEST_F(SchedulerTest, validConnectionHandle) {
		sp<IDisplayEventConnection> returnedValue;
		ASSERT_NO_FATAL_FAILURE(returnedValue =
		mScheduler->createDisplayEventConnection(mConnectionHandle));
		EXPECT_TRUE(returnedValue != nullptr);
		ASSERT_EQ(returnedValue, mEventThreadConnection);

		EXPECT_TRUE(mScheduler->getEventThread(mConnectionHandle) != nullptr);
		EXPECT_TRUE(mScheduler->getEventConnection(mConnectionHandle) != nullptr);

		EXPECT_CALL(*mEventThread, onHotplugReceived(EventThread::DisplayType::Primary, false))
		.Times(1);
		ASSERT_NO_FATAL_FAILURE(mScheduler->hotplugReceived(mConnectionHandle,
		EventThread::DisplayType::Primary, false));

		EXPECT_CALL(*mEventThread, onScreenAcquired()).Times(1);
		ASSERT_NO_FATAL_FAILURE(mScheduler->onScreenAcquired(mConnectionHandle));

		EXPECT_CALL(*mEventThread, onScreenReleased()).Times(1);
		ASSERT_NO_FATAL_FAILURE(mScheduler->onScreenReleased(mConnectionHandle));

		String8 testString("dump");
		EXPECT_CALL(*mEventThread, dump(testString)).Times(1);
		ASSERT_NO_FATAL_FAILURE(mScheduler->dump(mConnectionHandle, testString));
		EXPECT_TRUE(testString != "");

		EXPECT_CALL(*mEventThread, setPhaseOffset(10)).Times(1);
		ASSERT_NO_FATAL_FAILURE(mScheduler->setPhaseOffset(mConnectionHandle, 10));
		}

		} // namespace
		} // namespace android
		No newline at end of file