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