Merge "Refactor Power VTS in terms of AIDL version" into main (0b9cbcd0) · Commits · e / os / android_hardware_interfaces

power/aidl/vts/VtsHalPowerTargetTest.cpp

+48 −85

Original line number	Original line	Diff line number	Diff line
	@@ -29,7 +29,6 @@
	namespace aidl::android::hardware::power {		namespace aidl::android::hardware::power {
	namespace {		namespace {

	using ::android::base::GetUintProperty;
	using android::hardware::power::Boost;		using android::hardware::power::Boost;
	using android::hardware::power::IPower;		using android::hardware::power::IPower;
	using android::hardware::power::IPowerHintSession;		using android::hardware::power::IPowerHintSession;
	@@ -92,36 +91,33 @@ const std::vector<WorkDuration> kDurations = {
	DurationWrapper(1000000000L, 4L),		DurationWrapper(1000000000L, 4L),
	};		};

	// DEVICEs launching with Android 11 MUST meet the requirements for the
	// target-level=5 compatibility_matrix file.
	const uint64_t kCompatibilityMatrix5ApiLevel = 30;

	// DEVICEs launching with Android 13 MUST meet the requirements for the
	// target-level=7 compatibility_matrix file.
	const uint64_t kCompatibilityMatrix7ApiLevel = 33;

	// DEVICEs launching with Android 14 MUST meet the requirements for the
	// target-level=8 compatibility_matrix file.
	const uint64_t kCompatibilityMatrix8ApiLevel = 34;

	inline bool isUnknownOrUnsupported(const ndk::ScopedAStatus& status) {
	return status.getStatus() == STATUS_UNKNOWN_TRANSACTION \|\|
	status.getExceptionCode() == EX_UNSUPPORTED_OPERATION;
	}

	class PowerAidl : public testing::TestWithParam<std::string> {		class PowerAidl : public testing::TestWithParam<std::string> {
	public:		public:
	virtual void SetUp() override {		virtual void SetUp() override {
	AIBinder* binder = AServiceManager_waitForService(GetParam().c_str());		AIBinder* binder = AServiceManager_waitForService(GetParam().c_str());
	ASSERT_NE(binder, nullptr);		ASSERT_NE(binder, nullptr);
	power = IPower::fromBinder(ndk::SpAIBinder(binder));		power = IPower::fromBinder(ndk::SpAIBinder(binder));
			auto status = power->getInterfaceVersion(&mServiceVersion);
	mApiLevel = GetUintProperty<uint64_t>("ro.vendor.api_level", 0);		ASSERT_TRUE(status.isOk());
	ASSERT_NE(mApiLevel, 0);
	}		}

	std::shared_ptr<IPower> power;		std::shared_ptr<IPower> power;
	uint64_t mApiLevel;		int32_t mServiceVersion;
			};

			class HintSessionAidl : public PowerAidl {
			public:
			virtual void SetUp() override {
			PowerAidl::SetUp();
			if (mServiceVersion < 2) {
			GTEST_SKIP() << "DEVICE not launching with Power V2 and beyond.";
			}

			auto status = power->createHintSession(getpid(), getuid(), kSelfTids, 16666666L, &mSession);
			ASSERT_TRUE(status.isOk());
			ASSERT_NE(nullptr, mSession);
			}
			std::shared_ptr<IPowerHintSession> mSession;
	};		};

	TEST_P(PowerAidl, setMode) {		TEST_P(PowerAidl, setMode) {
	@@ -175,113 +171,80 @@ TEST_P(PowerAidl, isBoostSupported) {
	}		}

	TEST_P(PowerAidl, getHintSessionPreferredRate) {		TEST_P(PowerAidl, getHintSessionPreferredRate) {
	int64_t rate = -1;		if (mServiceVersion < 2) {
	auto status = power->getHintSessionPreferredRate(&rate);		GTEST_SKIP() << "DEVICE not launching with Power V2 and beyond.";
	if (mApiLevel < kCompatibilityMatrix7ApiLevel && !status.isOk()) {
	EXPECT_TRUE(isUnknownOrUnsupported(status));
	GTEST_SKIP() << "DEVICE not launching with Android 13 and beyond.";
	}		}
	ASSERT_TRUE(status.isOk());
			int64_t rate = -1;
			ASSERT_TRUE(power->getHintSessionPreferredRate(&rate).isOk());
	// At least 1ms rate limit from HAL		// At least 1ms rate limit from HAL
	ASSERT_GE(rate, 1000000);		ASSERT_GE(rate, 1000000);
	}		}

	TEST_P(PowerAidl, createAndCloseHintSession) {		TEST_P(HintSessionAidl, createAndCloseHintSession) {
	std::shared_ptr<IPowerHintSession> session;		ASSERT_TRUE(mSession->pause().isOk());
	auto status = power->createHintSession(getpid(), getuid(), kSelfTids, 16666666L, &session);		ASSERT_TRUE(mSession->resume().isOk());
	if (mApiLevel < kCompatibilityMatrix7ApiLevel && !status.isOk()) {
	EXPECT_TRUE(isUnknownOrUnsupported(status));
	GTEST_SKIP() << "DEVICE not launching with Android 13 and beyond.";
	}
	ASSERT_TRUE(status.isOk());
	ASSERT_NE(nullptr, session);
	ASSERT_TRUE(session->pause().isOk());
	ASSERT_TRUE(session->resume().isOk());
	// Test normal destroy operation		// Test normal destroy operation
	ASSERT_TRUE(session->close().isOk());		ASSERT_TRUE(mSession->close().isOk());
	session.reset();		mSession.reset();
	}		}

	TEST_P(PowerAidl, createHintSessionFailed) {		TEST_P(HintSessionAidl, createHintSessionFailed) {
	std::shared_ptr<IPowerHintSession> session;		std::shared_ptr<IPowerHintSession> session;
	auto status = power->createHintSession(getpid(), getuid(), kEmptyTids, 16666666L, &session);		auto status = power->createHintSession(getpid(), getuid(), kEmptyTids, 16666666L, &session);

	// Regardless of whether V2 and beyond is supported, the status is always not STATUS_OK.		// Regardless of whether V2 and beyond is supported, the status is always not STATUS_OK.
	ASSERT_FALSE(status.isOk());		ASSERT_FALSE(status.isOk());

	// If device not launching with Android 13 and beyond, check whether it's supported,
	// if not, skip the test.
	if (mApiLevel < kCompatibilityMatrix7ApiLevel && isUnknownOrUnsupported(status)) {
	GTEST_SKIP() << "DEVICE not launching with Android 13 and beyond.";
	}
	ASSERT_EQ(EX_ILLEGAL_ARGUMENT, status.getExceptionCode());		ASSERT_EQ(EX_ILLEGAL_ARGUMENT, status.getExceptionCode());
	}		}

	TEST_P(PowerAidl, updateAndReportDurations) {		TEST_P(HintSessionAidl, updateAndReportDurations) {
	std::shared_ptr<IPowerHintSession> session;		ASSERT_TRUE(mSession->updateTargetWorkDuration(16666667LL).isOk());
	auto status = power->createHintSession(getpid(), getuid(), kSelfTids, 16666666L, &session);		ASSERT_TRUE(mSession->reportActualWorkDuration(kDurations).isOk());
	if (mApiLevel < kCompatibilityMatrix7ApiLevel && !status.isOk()) {
	EXPECT_TRUE(isUnknownOrUnsupported(status));
	GTEST_SKIP() << "DEVICE not launching with Android 13 and beyond.";
	}		}
	ASSERT_TRUE(status.isOk());
	ASSERT_NE(nullptr, session);

	ASSERT_TRUE(session->updateTargetWorkDuration(16666667LL).isOk());		TEST_P(HintSessionAidl, sendSessionHint) {
	ASSERT_TRUE(session->reportActualWorkDuration(kDurations).isOk());		if (mServiceVersion < 4) {
			GTEST_SKIP() << "DEVICE not launching with Power V4 and beyond.";
	}		}

	TEST_P(PowerAidl, sendSessionHint) {
	std::shared_ptr<IPowerHintSession> session;
	auto status = power->createHintSession(getpid(), getuid(), kSelfTids, 16666666L, &session);
	if (!status.isOk()) {
	EXPECT_TRUE(isUnknownOrUnsupported(status));
	return;
	}
	for (const auto& sessionHint : kSessionHints) {		for (const auto& sessionHint : kSessionHints) {
	ASSERT_TRUE(session->sendHint(sessionHint).isOk());		ASSERT_TRUE(mSession->sendHint(sessionHint).isOk());
	}		}
	for (const auto& sessionHint : kInvalidSessionHints) {		for (const auto& sessionHint : kInvalidSessionHints) {
	ASSERT_TRUE(session->sendHint(sessionHint).isOk());		ASSERT_TRUE(mSession->sendHint(sessionHint).isOk());
	}		}
	}		}

	TEST_P(PowerAidl, setThreads) {		TEST_P(HintSessionAidl, setThreads) {
	std::shared_ptr<IPowerHintSession> session;		if (mServiceVersion < 4) {
	auto status = power->createHintSession(getpid(), getuid(), kSelfTids, 16666666L, &session);		GTEST_SKIP() << "DEVICE not launching with Power V4 and beyond.";
	if (mApiLevel < kCompatibilityMatrix7ApiLevel && !status.isOk()) {
	EXPECT_TRUE(isUnknownOrUnsupported(status));
	GTEST_SKIP() << "DEVICE not launching with Android 13 and beyond.";
	}		}
	ASSERT_TRUE(status.isOk());

	status = session->setThreads(kEmptyTids);		auto status = mSession->setThreads(kEmptyTids);
	if (mApiLevel < kCompatibilityMatrix8ApiLevel && isUnknownOrUnsupported(status)) {
	GTEST_SKIP() << "DEVICE not launching with Android 14 and beyond.";
	}
	ASSERT_FALSE(status.isOk());		ASSERT_FALSE(status.isOk());
	ASSERT_EQ(EX_ILLEGAL_ARGUMENT, status.getExceptionCode());		ASSERT_EQ(EX_ILLEGAL_ARGUMENT, status.getExceptionCode());

	status = session->setThreads(kSelfTids);		ASSERT_TRUE(mSession->setThreads(kSelfTids).isOk());
	ASSERT_TRUE(status.isOk());
	}		}

	// FIXED_PERFORMANCE mode is required for all devices which ship on Android 11		// FIXED_PERFORMANCE mode is required for all devices which ship on Android 11
	// or later		// or later
	TEST_P(PowerAidl, hasFixedPerformance) {		TEST_P(PowerAidl, hasFixedPerformance) {
	if (mApiLevel < kCompatibilityMatrix5ApiLevel) {
	GTEST_SKIP() << "FIXED_PERFORMANCE mode is only required for all devices launching Android "
	"11 or later.";
	}
	bool supported;		bool supported;
	ASSERT_TRUE(power->isModeSupported(Mode::FIXED_PERFORMANCE, &supported).isOk());		ASSERT_TRUE(power->isModeSupported(Mode::FIXED_PERFORMANCE, &supported).isOk());
	ASSERT_TRUE(supported);		ASSERT_TRUE(supported);
	}		}

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PowerAidl);		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PowerAidl);
			GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HintSessionAidl);

	INSTANTIATE_TEST_SUITE_P(Power, PowerAidl,		INSTANTIATE_TEST_SUITE_P(Power, PowerAidl,
	testing::ValuesIn(::android::getAidlHalInstanceNames(IPower::descriptor)),		testing::ValuesIn(::android::getAidlHalInstanceNames(IPower::descriptor)),
	::android::PrintInstanceNameToString);		::android::PrintInstanceNameToString);
			INSTANTIATE_TEST_SUITE_P(Power, HintSessionAidl,
			testing::ValuesIn(::android::getAidlHalInstanceNames(IPower::descriptor)),
			::android::PrintInstanceNameToString);

	} // namespace		} // namespace
	} // namespace aidl::android::hardware::power		} // namespace aidl::android::hardware::power