Some fixes to power manager lib code
- Run clang-format on all recently added files;
- Move all new classes to android::power namespace and remove Power
prefix from all classes and enums;
- Add virtual function specifier to overrides of virtual members;
- Add missing virtual destructors;
- Remove namespaces and aliases from public api of header files;
- Delete constructor and destructor of PowerHalLoader;
- Add helper functions to convert hal results in wrapper
implementations;
- Merge test targets to single libpowermanager_test target;
Bug: 150878220
Test: atest libpowermanager_test
Change-Id: Ie2b5ad69f3b05d5f6b576671bc98e0f83b274152
diff --git a/services/powermanager/tests/Android.bp b/services/powermanager/tests/Android.bp
index 70837cf..49abc11 100644
--- a/services/powermanager/tests/Android.bp
+++ b/services/powermanager/tests/Android.bp
@@ -13,9 +13,10 @@
// limitations under the License.
cc_test {
- name: "powermanager_test",
+ name: "libpowermanager_test",
test_suites: ["device-tests"],
srcs: [
+ "IThermalManagerTest.cpp",
"PowerHalControllerTest.cpp",
"PowerHalLoaderTest.cpp",
"PowerHalWrapperAidlTest.cpp",
@@ -42,22 +43,3 @@
"libgmock",
],
}
-
-cc_test {
- name: "thermalmanager_test",
- test_suites: ["device-tests"],
- srcs: ["IThermalManagerTest.cpp",],
- cflags: [
- "-Wall",
- "-Werror",
- "-Wextra",
- ],
- shared_libs: [
- "libbase",
- "libhidlbase",
- "liblog",
- "libpowermanager",
- "libbinder",
- "libutils",
- ],
-}
diff --git a/services/powermanager/tests/PowerHalControllerTest.cpp b/services/powermanager/tests/PowerHalControllerTest.cpp
index ac1e19a..141b244 100644
--- a/services/powermanager/tests/PowerHalControllerTest.cpp
+++ b/services/powermanager/tests/PowerHalControllerTest.cpp
@@ -19,15 +19,12 @@
#include <android/hardware/power/Boost.h>
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-
-#include <powermanager/PowerHalWrapper.h>
#include <powermanager/PowerHalController.h>
+#include <utils/Log.h>
#include <thread>
-#include <utils/Log.h>
using android::hardware::power::Boost;
using android::hardware::power::Mode;
@@ -36,6 +33,7 @@
using android::hardware::power::V1_0::PowerHint;
using namespace android;
+using namespace android::power;
using namespace std::chrono_literals;
using namespace testing;
@@ -45,23 +43,21 @@
public:
MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
- MOCK_METHOD(
- hardware::Return<void>, getPlatformLowPowerStats,
- (getPlatformLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
+ MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
+ (getPlatformLowPowerStats_cb _hidl_cb), (override));
};
-class TestPowerHalConnector : public PowerHalConnector {
+class TestPowerHalConnector : public HalConnector {
public:
TestPowerHalConnector(sp<IPower> powerHal) : mHal(std::move(powerHal)) {}
virtual ~TestPowerHalConnector() = default;
- virtual std::unique_ptr<PowerHalWrapper> connect() override {
+ virtual std::unique_ptr<HalWrapper> connect() override {
mCountMutex.lock();
++mConnectedCount;
mCountMutex.unlock();
- return std::make_unique<HidlPowerHalWrapperV1_0>(mHal);
+ return std::make_unique<HidlHalWrapperV1_0>(mHal);
}
void reset() override {
@@ -70,13 +66,9 @@
mCountMutex.unlock();
}
- int getConnectCount() {
- return mConnectedCount;
- }
+ int getConnectCount() { return mConnectedCount; }
- int getResetCount() {
- return mResetCount;
- }
+ int getResetCount() { return mResetCount; }
private:
sp<IPower> mHal = nullptr;
@@ -89,8 +81,8 @@
public:
AlwaysFailingTestPowerHalConnector() : TestPowerHalConnector(nullptr) {}
- std::unique_ptr<PowerHalWrapper> connect() override {
- // Call parent to update counter, but ignore connected PowerHalWrapper.
+ std::unique_ptr<HalWrapper> connect() override {
+ // Call parent to update counter, but ignore connected HalWrapper.
TestPowerHalConnector::connect();
return nullptr;
}
@@ -103,7 +95,7 @@
void SetUp() override {
mMockHal = new StrictMock<MockIPowerV1_0>();
std::unique_ptr<TestPowerHalConnector> halConnector =
- std::make_unique<TestPowerHalConnector>(mMockHal);
+ std::make_unique<TestPowerHalConnector>(mMockHal);
mHalConnector = halConnector.get();
mHalController = std::make_unique<PowerHalController>(std::move(halConnector));
}
@@ -132,20 +124,22 @@
TEST_F(PowerHalControllerTest, TestUnableToConnectToPowerHalIgnoresAllApiCalls) {
std::unique_ptr<AlwaysFailingTestPowerHalConnector> halConnector =
- std::make_unique<AlwaysFailingTestPowerHalConnector>();
+ std::make_unique<AlwaysFailingTestPowerHalConnector>();
AlwaysFailingTestPowerHalConnector* failingHalConnector = halConnector.get();
PowerHalController halController(std::move(halConnector));
int powerHalConnectCount = failingHalConnector->getConnectCount();
EXPECT_EQ(powerHalConnectCount, 0);
- // Still works with EmptyPowerHalWrapper as fallback ignoring every api call and logging.
+ // Still works with EmptyPowerHalWrapper as fallback ignoring every api call
+ // and logging.
auto result = halController.setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
result = halController.setMode(Mode::LAUNCH, true);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
- // PowerHalConnector was called every time to attempt to reconnect with underlying service.
+ // PowerHalConnector was called every time to attempt to reconnect with
+ // underlying service.
powerHalConnectCount = failingHalConnector->getConnectCount();
EXPECT_EQ(powerHalConnectCount, 2);
// PowerHalConnector was never reset.
@@ -160,15 +154,14 @@
{
InSequence seg;
EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(100)))
- .Times(Exactly(1));
- EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
+ EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1))).Times(Exactly(1));
}
auto result = mHalController->setBoost(Boost::INTERACTION, 100);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mHalController->setMode(Mode::LAUNCH, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
// PowerHalConnector was called only once and never reset.
powerHalConnectCount = mHalConnector->getConnectCount();
@@ -182,23 +175,23 @@
EXPECT_EQ(powerHalConnectCount, 0);
ON_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), _))
- .WillByDefault([](PowerHint, int32_t) {
- return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .WillByDefault([](PowerHint, int32_t) {
+ return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
+ });
- EXPECT_CALL(*mMockHal.get(), powerHint(_, _))
- .Times(Exactly(4));
+ EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(Exactly(4));
auto result = mHalController->setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mHalController->setMode(Mode::LAUNCH, true);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
result = mHalController->setMode(Mode::VR, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mHalController->setMode(Mode::LOW_POWER, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
- // PowerHalConnector was called only twice: on first api call and after failed call.
+ // PowerHalConnector was called only twice: on first api call and after failed
+ // call.
powerHalConnectCount = mHalConnector->getConnectCount();
EXPECT_EQ(powerHalConnectCount, 2);
// PowerHalConnector was reset once after failed call.
@@ -211,9 +204,9 @@
EXPECT_EQ(powerHalConnectCount, 0);
auto result = mHalController->setBoost(Boost::CAMERA_LAUNCH, 1000);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
result = mHalController->setMode(Mode::CAMERA_STREAMING_HIGH, true);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
// PowerHalConnector was called only once and never reset.
powerHalConnectCount = mHalConnector->getConnectCount();
@@ -226,19 +219,19 @@
int powerHalConnectCount = mHalConnector->getConnectCount();
EXPECT_EQ(powerHalConnectCount, 0);
- EXPECT_CALL(*mMockHal.get(), powerHint(_, _))
- .Times(Exactly(10));
+ EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(Exactly(10));
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
threads.push_back(std::thread([&]() {
auto result = mHalController->setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}));
}
std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); });
- // PowerHalConnector was called only by the first thread to use the api and never reset.
+ // PowerHalConnector was called only by the first thread to use the api and
+ // never reset.
powerHalConnectCount = mHalConnector->getConnectCount();
EXPECT_EQ(powerHalConnectCount, 1);
int powerHalResetCount = mHalConnector->getResetCount();
@@ -250,36 +243,36 @@
EXPECT_EQ(powerHalConnectCount, 0);
ON_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), _))
- .WillByDefault([](PowerHint, int32_t) {
- return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .WillByDefault([](PowerHint, int32_t) {
+ return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
+ });
- EXPECT_CALL(*mMockHal.get(), powerHint(_, _))
- .Times(Exactly(40));
+ EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(Exactly(40));
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
threads.push_back(std::thread([&]() {
auto result = mHalController->setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}));
threads.push_back(std::thread([&]() {
auto result = mHalController->setMode(Mode::LAUNCH, true);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
}));
threads.push_back(std::thread([&]() {
auto result = mHalController->setMode(Mode::LOW_POWER, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}));
threads.push_back(std::thread([&]() {
auto result = mHalController->setMode(Mode::VR, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}));
}
std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); });
// PowerHalConnector was called at least once by the first thread.
- // Reset and reconnect calls were made at most 10 times, once after each failure.
+ // Reset and reconnect calls were made at most 10 times, once after each
+ // failure.
powerHalConnectCount = mHalConnector->getConnectCount();
EXPECT_THAT(powerHalConnectCount, AllOf(Ge(1), Le(11)));
int powerHalResetCount = mHalConnector->getResetCount();
diff --git a/services/powermanager/tests/PowerHalLoaderTest.cpp b/services/powermanager/tests/PowerHalLoaderTest.cpp
index 2310a72..058e1b5 100644
--- a/services/powermanager/tests/PowerHalLoaderTest.cpp
+++ b/services/powermanager/tests/PowerHalLoaderTest.cpp
@@ -19,17 +19,18 @@
#include <android-base/logging.h>
#include <android/hardware/power/1.1/IPower.h>
#include <android/hardware/power/IPower.h>
+#include <gtest/gtest.h>
+#include <powermanager/PowerHalLoader.h>
#include <future>
-#include <gtest/gtest.h>
-
-#include <powermanager/PowerHalLoader.h>
using IPowerV1_0 = android::hardware::power::V1_0::IPower;
using IPowerV1_1 = android::hardware::power::V1_1::IPower;
using IPowerAidl = android::hardware::power::IPower;
using namespace android;
+using namespace android::power;
+using namespace testing;
// -------------------------------------------------------------------------------------------------
@@ -54,14 +55,10 @@
// -------------------------------------------------------------------------------------------------
template <typename T>
-class PowerHalLoaderTest : public testing::Test {
+class PowerHalLoaderTest : public Test {
public:
- sp<T> load() {
- return ::loadHal<T>();
- }
- void unload() {
- PowerHalLoader::unloadAll();
- }
+ sp<T> load() { return ::loadHal<T>(); }
+ void unload() { PowerHalLoader::unloadAll(); }
};
// -------------------------------------------------------------------------------------------------
@@ -95,7 +92,7 @@
std::vector<std::future<sp<TypeParam>>> futures;
for (int i = 0; i < 10; i++) {
futures.push_back(
- std::async(std::launch::async, &PowerHalLoaderTest<TypeParam>::load, this));
+ std::async(std::launch::async, &PowerHalLoaderTest<TypeParam>::load, this));
}
futures[0].wait();
diff --git a/services/powermanager/tests/PowerHalWrapperAidlTest.cpp b/services/powermanager/tests/PowerHalWrapperAidlTest.cpp
index 73b7466..a765659 100644
--- a/services/powermanager/tests/PowerHalWrapperAidlTest.cpp
+++ b/services/powermanager/tests/PowerHalWrapperAidlTest.cpp
@@ -19,14 +19,12 @@
#include <android/hardware/power/Boost.h>
#include <android/hardware/power/Mode.h>
#include <binder/IServiceManager.h>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-
#include <powermanager/PowerHalWrapper.h>
+#include <utils/Log.h>
#include <thread>
-#include <utils/Log.h>
using android::binder::Status;
using android::hardware::power::Boost;
@@ -34,6 +32,7 @@
using android::hardware::power::Mode;
using namespace android;
+using namespace android::power;
using namespace std::chrono_literals;
using namespace testing;
@@ -57,7 +56,7 @@
void SetUp() override;
protected:
- std::unique_ptr<PowerHalWrapper> mWrapper = nullptr;
+ std::unique_ptr<HalWrapper> mWrapper = nullptr;
sp<StrictMock<MockIPower>> mMockHal = nullptr;
};
@@ -65,7 +64,7 @@
void PowerHalWrapperAidlTest::SetUp() {
mMockHal = new StrictMock<MockIPower>();
- mWrapper = std::make_unique<AidlPowerHalWrapper>(mMockHal);
+ mWrapper = std::make_unique<AidlHalWrapper>(mMockHal);
ASSERT_NE(mWrapper, nullptr);
}
@@ -75,62 +74,61 @@
{
InSequence seq;
EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::DISPLAY_UPDATE_IMMINENT), _))
- .Times(Exactly(1))
- .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
+ .Times(Exactly(1))
+ .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
EXPECT_CALL(*mMockHal.get(), setBoost(Eq(Boost::DISPLAY_UPDATE_IMMINENT), Eq(100)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
}
auto result = mWrapper->setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 100);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}
TEST_F(PowerHalWrapperAidlTest, TestSetBoostFailed) {
{
InSequence seq;
EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::INTERACTION), _))
- .Times(Exactly(1))
- .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
+ .Times(Exactly(1))
+ .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
EXPECT_CALL(*mMockHal.get(), setBoost(Eq(Boost::INTERACTION), Eq(100)))
- .Times(Exactly(1))
- .WillRepeatedly(Return(Status::fromExceptionCode(-1)));
+ .Times(Exactly(1))
+ .WillRepeatedly(Return(Status::fromExceptionCode(-1)));
EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::DISPLAY_UPDATE_IMMINENT), _))
- .Times(Exactly(1))
- .WillRepeatedly(Return(Status::fromExceptionCode(-1)));
+ .Times(Exactly(1))
+ .WillRepeatedly(Return(Status::fromExceptionCode(-1)));
}
auto result = mWrapper->setBoost(Boost::INTERACTION, 100);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
result = mWrapper->setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 1000);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
}
TEST_F(PowerHalWrapperAidlTest, TestSetBoostUnsupported) {
EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::INTERACTION), _))
- .Times(Exactly(1))
- .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status())));
+ .Times(Exactly(1))
+ .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status())));
auto result = mWrapper->setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
result = mWrapper->setBoost(Boost::CAMERA_SHOT, 10);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
}
TEST_F(PowerHalWrapperAidlTest, TestSetBoostMultiThreadCheckSupportedOnlyOnce) {
{
InSequence seq;
EXPECT_CALL(*mMockHal.get(), isBoostSupported(Eq(Boost::INTERACTION), _))
- .Times(Exactly(1))
- .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
- EXPECT_CALL(*mMockHal.get(), setBoost(Eq(Boost::INTERACTION), Eq(100)))
- .Times(Exactly(10));
+ .Times(Exactly(1))
+ .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
+ EXPECT_CALL(*mMockHal.get(), setBoost(Eq(Boost::INTERACTION), Eq(100))).Times(Exactly(10));
}
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
threads.push_back(std::thread([&]() {
auto result = mWrapper->setBoost(Boost::INTERACTION, 100);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}));
}
std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); });
@@ -140,62 +138,61 @@
{
InSequence seq;
EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::DISPLAY_INACTIVE), _))
- .Times(Exactly(1))
- .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
+ .Times(Exactly(1))
+ .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
EXPECT_CALL(*mMockHal.get(), setMode(Eq(Mode::DISPLAY_INACTIVE), Eq(false)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
}
auto result = mWrapper->setMode(Mode::DISPLAY_INACTIVE, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}
TEST_F(PowerHalWrapperAidlTest, TestSetModeFailed) {
{
InSequence seq;
EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::LAUNCH), _))
- .Times(Exactly(1))
- .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
+ .Times(Exactly(1))
+ .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
EXPECT_CALL(*mMockHal.get(), setMode(Eq(Mode::LAUNCH), Eq(true)))
- .Times(Exactly(1))
- .WillRepeatedly(Return(Status::fromExceptionCode(-1)));
+ .Times(Exactly(1))
+ .WillRepeatedly(Return(Status::fromExceptionCode(-1)));
EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::DISPLAY_INACTIVE), _))
- .Times(Exactly(1))
- .WillRepeatedly(Return(Status::fromExceptionCode(-1)));
+ .Times(Exactly(1))
+ .WillRepeatedly(Return(Status::fromExceptionCode(-1)));
}
auto result = mWrapper->setMode(Mode::LAUNCH, true);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
result = mWrapper->setMode(Mode::DISPLAY_INACTIVE, false);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
}
TEST_F(PowerHalWrapperAidlTest, TestSetModeUnsupported) {
EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::LAUNCH), _))
- .Times(Exactly(1))
- .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status())));
+ .Times(Exactly(1))
+ .WillRepeatedly(DoAll(SetArgPointee<1>(false), Return(Status())));
auto result = mWrapper->setMode(Mode::LAUNCH, true);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
}
TEST_F(PowerHalWrapperAidlTest, TestSetModeMultiThreadCheckSupportedOnlyOnce) {
{
InSequence seq;
EXPECT_CALL(*mMockHal.get(), isModeSupported(Eq(Mode::LAUNCH), _))
- .Times(Exactly(1))
- .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
- EXPECT_CALL(*mMockHal.get(), setMode(Eq(Mode::LAUNCH), Eq(false)))
- .Times(Exactly(10));
+ .Times(Exactly(1))
+ .WillRepeatedly(DoAll(SetArgPointee<1>(true), Return(Status())));
+ EXPECT_CALL(*mMockHal.get(), setMode(Eq(Mode::LAUNCH), Eq(false))).Times(Exactly(10));
}
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
threads.push_back(std::thread([&]() {
auto result = mWrapper->setMode(Mode::LAUNCH, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}));
}
std::for_each(threads.begin(), threads.end(), [](std::thread& t) { t.join(); });
diff --git a/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp b/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp
index 5379054..6693d0b 100644
--- a/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp
+++ b/services/powermanager/tests/PowerHalWrapperHidlV1_0Test.cpp
@@ -20,12 +20,9 @@
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
#include <binder/IServiceManager.h>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-
#include <powermanager/PowerHalWrapper.h>
-
#include <utils/Log.h>
using android::hardware::power::Boost;
@@ -35,6 +32,7 @@
using android::hardware::power::V1_0::PowerHint;
using namespace android;
+using namespace android::power;
using namespace std::chrono_literals;
using namespace testing;
@@ -44,11 +42,9 @@
public:
MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
- MOCK_METHOD(
- hardware::Return<void>, getPlatformLowPowerStats,
- (getPlatformLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
+ MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
+ (getPlatformLowPowerStats_cb _hidl_cb), (override));
};
// -------------------------------------------------------------------------------------------------
@@ -58,7 +54,7 @@
void SetUp() override;
protected:
- std::unique_ptr<PowerHalWrapper> mWrapper = nullptr;
+ std::unique_ptr<HalWrapper> mWrapper = nullptr;
sp<StrictMock<MockIPowerV1_0>> mMockHal = nullptr;
};
@@ -66,80 +62,75 @@
void PowerHalWrapperHidlV1_0Test::SetUp() {
mMockHal = new StrictMock<MockIPowerV1_0>();
- mWrapper = std::make_unique<HidlPowerHalWrapperV1_0>(mMockHal);
+ mWrapper = std::make_unique<HidlHalWrapperV1_0>(mMockHal);
ASSERT_NE(mWrapper, nullptr);
}
// -------------------------------------------------------------------------------------------------
TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostSuccessful) {
- EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000)))
- .Times(Exactly(1));
+ EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000))).Times(Exactly(1));
auto result = mWrapper->setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}
TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostFailed) {
EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000)))
- .Times(Exactly(1))
- .WillRepeatedly([](PowerHint, int32_t) {
- return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .Times(Exactly(1))
+ .WillRepeatedly([](PowerHint, int32_t) {
+ return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
+ });
auto result = mWrapper->setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
}
TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostUnsupported) {
auto result = mWrapper->setBoost(Boost::CAMERA_LAUNCH, 10);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
}
TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeSuccessful) {
{
InSequence seq;
- EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1)))
- .Times(Exactly(1));
- EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LOW_POWER), Eq(0)))
- .Times(Exactly(1));
+ EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1))).Times(Exactly(1));
+ EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LOW_POWER), Eq(0))).Times(Exactly(1));
EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::SUSTAINED_PERFORMANCE), Eq(1)))
- .Times(Exactly(1));
- EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::VR_MODE), Eq(0)))
- .Times(Exactly(1));
- EXPECT_CALL(*mMockHal.get(), setInteractive(Eq(true)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
+ EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::VR_MODE), Eq(0))).Times(Exactly(1));
+ EXPECT_CALL(*mMockHal.get(), setInteractive(Eq(true))).Times(Exactly(1));
EXPECT_CALL(*mMockHal.get(),
setFeature(Eq(Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE), Eq(false)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
}
auto result = mWrapper->setMode(Mode::LAUNCH, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::LOW_POWER, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::SUSTAINED_PERFORMANCE, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::VR, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::INTERACTIVE, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::DOUBLE_TAP_TO_WAKE, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}
TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeFailed) {
EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1)))
- .Times(Exactly(1))
- .WillRepeatedly([](PowerHint, int32_t) {
- return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .Times(Exactly(1))
+ .WillRepeatedly([](PowerHint, int32_t) {
+ return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
+ });
auto result = mWrapper->setMode(Mode::LAUNCH, 1);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
}
TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeIgnored) {
auto result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
}
diff --git a/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp b/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp
index 931c0d5..55bbd6d 100644
--- a/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp
+++ b/services/powermanager/tests/PowerHalWrapperHidlV1_1Test.cpp
@@ -21,12 +21,9 @@
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/Mode.h>
#include <binder/IServiceManager.h>
-
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-
#include <powermanager/PowerHalWrapper.h>
-
#include <utils/Log.h>
using android::hardware::power::Boost;
@@ -37,6 +34,7 @@
using IPowerV1_0 = android::hardware::power::V1_0::IPower;
using namespace android;
+using namespace android::power;
using namespace std::chrono_literals;
using namespace testing;
@@ -46,27 +44,21 @@
public:
MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
- MOCK_METHOD(
- hardware::Return<void>, getPlatformLowPowerStats,
- (getPlatformLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
+ MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
+ (getPlatformLowPowerStats_cb _hidl_cb), (override));
};
class MockIPowerV1_1 : public IPowerV1_1 {
public:
MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
- MOCK_METHOD(
- hardware::Return<void>, getPlatformLowPowerStats,
- (getPlatformLowPowerStats_cb _hidl_cb), (override));
- MOCK_METHOD(
- hardware::Return<void>, powerHintAsync, (PowerHint hint, int32_t data), (override));
- MOCK_METHOD(
- hardware::Return<void>, getSubsystemLowPowerStats,
- (getSubsystemLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
+ MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
+ (getPlatformLowPowerStats_cb _hidl_cb), (override));
+ MOCK_METHOD(hardware::Return<void>, powerHintAsync, (PowerHint hint, int32_t data), (override));
+ MOCK_METHOD(hardware::Return<void>, getSubsystemLowPowerStats,
+ (getSubsystemLowPowerStats_cb _hidl_cb), (override));
};
// -------------------------------------------------------------------------------------------------
@@ -76,7 +68,7 @@
void SetUp() override;
protected:
- std::unique_ptr<PowerHalWrapper> mWrapper = nullptr;
+ std::unique_ptr<HalWrapper> mWrapper = nullptr;
sp<StrictMock<MockIPowerV1_0>> mMockHalV1_0 = nullptr;
sp<StrictMock<MockIPowerV1_1>> mMockHalV1_1 = nullptr;
};
@@ -86,7 +78,7 @@
void PowerHalWrapperHidlV1_1Test::SetUp() {
mMockHalV1_0 = new StrictMock<MockIPowerV1_0>();
mMockHalV1_1 = new StrictMock<MockIPowerV1_1>();
- mWrapper = std::make_unique<HidlPowerHalWrapperV1_1>(mMockHalV1_0, mMockHalV1_1);
+ mWrapper = std::make_unique<HidlHalWrapperV1_1>(mMockHalV1_0, mMockHalV1_1);
ASSERT_NE(mWrapper, nullptr);
}
@@ -94,72 +86,72 @@
TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostSuccessful) {
EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::INTERACTION), Eq(1000)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
auto result = mWrapper->setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}
TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostFailed) {
EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::INTERACTION), Eq(1000)))
- .Times(Exactly(1))
- .WillRepeatedly([](PowerHint, int32_t) {
- return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .Times(Exactly(1))
+ .WillRepeatedly([](PowerHint, int32_t) {
+ return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
+ });
auto result = mWrapper->setBoost(Boost::INTERACTION, 1000);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
}
TEST_F(PowerHalWrapperHidlV1_1Test, TestSetBoostUnsupported) {
auto result = mWrapper->setBoost(Boost::CAMERA_LAUNCH, 10);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
}
TEST_F(PowerHalWrapperHidlV1_1Test, TestSetMode) {
{
InSequence seq;
EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::LAUNCH), Eq(1)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::LOW_POWER), Eq(0)))
- .Times(Exactly(1));
- EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::SUSTAINED_PERFORMANCE), Eq(1)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
+ EXPECT_CALL(*mMockHalV1_1.get(),
+ powerHintAsync(Eq(PowerHint::SUSTAINED_PERFORMANCE), Eq(1)))
+ .Times(Exactly(1));
EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::VR_MODE), Eq(0)))
- .Times(Exactly(1));
- EXPECT_CALL(*mMockHalV1_0.get(), setInteractive(Eq(true)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
+ EXPECT_CALL(*mMockHalV1_0.get(), setInteractive(Eq(true))).Times(Exactly(1));
EXPECT_CALL(*mMockHalV1_0.get(),
setFeature(Eq(Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE), Eq(false)))
- .Times(Exactly(1));
+ .Times(Exactly(1));
}
auto result = mWrapper->setMode(Mode::LAUNCH, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::LOW_POWER, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::SUSTAINED_PERFORMANCE, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::VR, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::INTERACTIVE, true);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
result = mWrapper->setMode(Mode::DOUBLE_TAP_TO_WAKE, false);
- ASSERT_EQ(PowerHalResult::SUCCESSFUL, result);
+ ASSERT_EQ(HalResult::SUCCESSFUL, result);
}
TEST_F(PowerHalWrapperHidlV1_1Test, TestSetModeFailed) {
EXPECT_CALL(*mMockHalV1_1.get(), powerHintAsync(Eq(PowerHint::LAUNCH), Eq(1)))
- .Times(Exactly(1))
- .WillRepeatedly([](PowerHint, int32_t) {
- return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
- });
+ .Times(Exactly(1))
+ .WillRepeatedly([](PowerHint, int32_t) {
+ return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
+ });
auto result = mWrapper->setMode(Mode::LAUNCH, 1);
- ASSERT_EQ(PowerHalResult::FAILED, result);
+ ASSERT_EQ(HalResult::FAILED, result);
}
TEST_F(PowerHalWrapperHidlV1_1Test, TestSetModeIgnored) {
auto result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true);
- ASSERT_EQ(PowerHalResult::UNSUPPORTED, result);
+ ASSERT_EQ(HalResult::UNSUPPORTED, result);
}