1 /*
2  * Copyright (C) 2020 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  */
16 
17 #define LOG_TAG "PowerHalWrapperHidlV1_0Test"
18 
19 #include <aidl/android/hardware/power/Boost.h>
20 #include <aidl/android/hardware/power/IPower.h>
21 #include <aidl/android/hardware/power/Mode.h>
22 #include <binder/IServiceManager.h>
23 #include <gmock/gmock.h>
24 #include <gtest/gtest.h>
25 #include <powermanager/PowerHalWrapper.h>
26 #include <utils/Log.h>
27 
28 using aidl::android::hardware::power::Boost;
29 using aidl::android::hardware::power::Mode;
30 using android::hardware::power::V1_0::Feature;
31 using android::hardware::power::V1_0::IPower;
32 using android::hardware::power::V1_0::PowerHint;
33 
34 using namespace android;
35 using namespace android::power;
36 using namespace std::chrono_literals;
37 using namespace testing;
38 
39 // -------------------------------------------------------------------------------------------------
40 
41 class MockIPowerV1_0 : public IPower {
42 public:
43     MOCK_METHOD(hardware::Return<void>, setInteractive, (bool interactive), (override));
44     MOCK_METHOD(hardware::Return<void>, powerHint, (PowerHint hint, int32_t data), (override));
45     MOCK_METHOD(hardware::Return<void>, setFeature, (Feature feature, bool activate), (override));
46     MOCK_METHOD(hardware::Return<void>, getPlatformLowPowerStats,
47                 (getPlatformLowPowerStats_cb _hidl_cb), (override));
48 };
49 
50 // -------------------------------------------------------------------------------------------------
51 
52 class PowerHalWrapperHidlV1_0Test : public Test {
53 public:
54     void SetUp() override;
55 
56 protected:
57     std::unique_ptr<HalWrapper> mWrapper = nullptr;
58     sp<StrictMock<MockIPowerV1_0>> mMockHal = nullptr;
59 };
60 
61 // -------------------------------------------------------------------------------------------------
62 
SetUp()63 void PowerHalWrapperHidlV1_0Test::SetUp() {
64     mMockHal = new StrictMock<MockIPowerV1_0>();
65     mWrapper = std::make_unique<HidlHalWrapperV1_0>(mMockHal);
66     ASSERT_NE(mWrapper, nullptr);
67 }
68 
69 // -------------------------------------------------------------------------------------------------
70 
TEST_F(PowerHalWrapperHidlV1_0Test,TestSetBoostSuccessful)71 TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostSuccessful) {
72     EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000))).Times(Exactly(1));
73 
74     auto result = mWrapper->setBoost(Boost::INTERACTION, 1000);
75     ASSERT_TRUE(result.isOk());
76 }
77 
TEST_F(PowerHalWrapperHidlV1_0Test,TestSetBoostFailed)78 TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostFailed) {
79     EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::INTERACTION), Eq(1000)))
80             .Times(Exactly(1))
81             .WillRepeatedly([](PowerHint, int32_t) {
82                 return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
83             });
84 
85     auto result = mWrapper->setBoost(Boost::INTERACTION, 1000);
86     ASSERT_TRUE(result.isFailed());
87 }
88 
TEST_F(PowerHalWrapperHidlV1_0Test,TestSetBoostUnsupported)89 TEST_F(PowerHalWrapperHidlV1_0Test, TestSetBoostUnsupported) {
90     EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(0);
91     EXPECT_CALL(*mMockHal.get(), setInteractive(_)).Times(0);
92     EXPECT_CALL(*mMockHal.get(), setFeature(_, _)).Times(0);
93 
94     auto result = mWrapper->setBoost(Boost::CAMERA_LAUNCH, 10);
95     ASSERT_TRUE(result.isUnsupported());
96     result = mWrapper->setBoost(Boost::ML_ACC, 10);
97     ASSERT_TRUE(result.isUnsupported());
98     result = mWrapper->setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 10);
99     ASSERT_TRUE(result.isUnsupported());
100 }
101 
TEST_F(PowerHalWrapperHidlV1_0Test,TestSetModeSuccessful)102 TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeSuccessful) {
103     {
104         InSequence seq;
105         EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(true))).Times(Exactly(1));
106         EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LOW_POWER), Eq(false)))
107                 .Times(Exactly(1));
108         EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::SUSTAINED_PERFORMANCE), Eq(true)))
109                 .Times(Exactly(1));
110         EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::VR_MODE), Eq(false)))
111                 .Times(Exactly(1));
112         EXPECT_CALL(*mMockHal.get(), setInteractive(Eq(true))).Times(Exactly(1));
113         EXPECT_CALL(*mMockHal.get(),
114                     setFeature(Eq(Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE), Eq(false)))
115                 .Times(Exactly(1));
116     }
117 
118     auto result = mWrapper->setMode(Mode::LAUNCH, true);
119     ASSERT_TRUE(result.isOk());
120     result = mWrapper->setMode(Mode::LOW_POWER, false);
121     ASSERT_TRUE(result.isOk());
122     result = mWrapper->setMode(Mode::SUSTAINED_PERFORMANCE, true);
123     ASSERT_TRUE(result.isOk());
124     result = mWrapper->setMode(Mode::VR, false);
125     ASSERT_TRUE(result.isOk());
126     result = mWrapper->setMode(Mode::INTERACTIVE, true);
127     ASSERT_TRUE(result.isOk());
128     result = mWrapper->setMode(Mode::DOUBLE_TAP_TO_WAKE, false);
129     ASSERT_TRUE(result.isOk());
130 }
131 
TEST_F(PowerHalWrapperHidlV1_0Test,TestSetModeFailed)132 TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeFailed) {
133     EXPECT_CALL(*mMockHal.get(), powerHint(Eq(PowerHint::LAUNCH), Eq(1)))
134             .Times(Exactly(1))
135             .WillRepeatedly([](PowerHint, int32_t) {
136                 return hardware::Return<void>(hardware::Status::fromExceptionCode(-1));
137             });
138 
139     auto result = mWrapper->setMode(Mode::LAUNCH, 1);
140     ASSERT_TRUE(result.isFailed());
141 }
142 
TEST_F(PowerHalWrapperHidlV1_0Test,TestSetModeIgnored)143 TEST_F(PowerHalWrapperHidlV1_0Test, TestSetModeIgnored) {
144     EXPECT_CALL(*mMockHal.get(), powerHint(_, _)).Times(0);
145     EXPECT_CALL(*mMockHal.get(), setInteractive(_)).Times(0);
146     EXPECT_CALL(*mMockHal.get(), setFeature(_, _)).Times(0);
147 
148     auto result = mWrapper->setMode(Mode::CAMERA_STREAMING_HIGH, true);
149     ASSERT_TRUE(result.isUnsupported());
150     result = mWrapper->setMode(Mode::EXPENSIVE_RENDERING, false);
151     ASSERT_TRUE(result.isUnsupported());
152     result = mWrapper->setMode(Mode::FIXED_PERFORMANCE, true);
153     ASSERT_TRUE(result.isUnsupported());
154     result = mWrapper->setMode(Mode::GAME_LOADING, false);
155     ASSERT_TRUE(result.isUnsupported());
156 }
157