1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <algorithm>
17 #include <cmath>
18 #include <cstdio>
19 #include <gtest/gtest.h>
20 #include <mutex>
21 #include <fcntl.h>
22 #include <functional>
23 #include <securec.h>
24 #include <unistd.h>
25
26 #include "hdf_base.h"
27 #include "osal_time.h"
28 #include "v1_0/ipower_interface.h"
29 #include "v1_0/ipower_hdi_callback.h"
30 #include "v1_0/power_types.h"
31
32 using namespace OHOS::HDI;
33 using namespace OHOS::HDI::Power::V1_0;
34 using namespace testing::ext;
35
36 namespace {
37 class PowerHdiCallback : public IPowerHdiCallback {
38 public:
~PowerHdiCallback()39 ~PowerHdiCallback() override {};
OnSuspend()40 int32_t OnSuspend() override
41 {
42 return 0;
43 };
44
OnWakeup()45 int32_t OnWakeup() override
46 {
47 return 0;
48 };
49 };
50
51 sptr<IPowerHdiCallback> g_callback = new PowerHdiCallback();
52 sptr<IPowerInterface> g_powerInterface = nullptr;
53 std::mutex g_mutex;
54 const uint32_t MAX_PATH = 256;
55 const uint32_t WAIT_TIME = 1;
56 const std::string SUSPEND_STATE = "mem";
57 const std::string SUSPEND_STATE_PATH = "/sys/power/state";
58 const std::string LOCK_PATH = "/sys/power/wake_lock";
59 const std::string UNLOCK_PATH = "/sys/power/wake_unlock";
60 const std::string WAKEUP_COUNT_PATH = "/sys/power/wakeup_count";
61
62 class HdfPowerHdiTest : public testing::Test {
63 public:
64 static void SetUpTestCase();
65 static void TearDownTestCase();
66 void SetUp();
67 void TearDown();
68 static int32_t ReadFile(const char *path, char *buf, size_t size);
69 };
70
SetUpTestCase()71 void HdfPowerHdiTest::SetUpTestCase()
72 {
73 g_powerInterface = IPowerInterface::Get(true);
74 }
75
TearDownTestCase()76 void HdfPowerHdiTest::TearDownTestCase()
77 {
78 }
79
SetUp()80 void HdfPowerHdiTest::SetUp()
81 {
82 }
83
TearDown()84 void HdfPowerHdiTest::TearDown()
85 {
86 }
87
ReadFile(const char * path,char * buf,size_t size)88 int32_t HdfPowerHdiTest::ReadFile(const char *path, char *buf, size_t size)
89 {
90 std::lock_guard<std::mutex> lock(g_mutex);
91 int32_t ret;
92
93 int32_t fd = open(path, O_RDONLY, S_IRUSR | S_IRGRP | S_IROTH);
94 if (fd < HDF_SUCCESS) {
95 return HDF_FAILURE;
96 }
97
98 ret = read(fd, buf, size);
99 if (ret < HDF_SUCCESS) {
100 close(fd);
101 return HDF_FAILURE;
102 }
103
104 close(fd);
105 buf[size - 1] = '\0';
106 return HDF_SUCCESS;
107 }
108 }
109
110 namespace {
111 /**
112 * @tc.name: HdfPowerHdiTest001
113 * @tc.desc: Get a client and check whether the client is empty.
114 * @tc.type: FUNC
115 */
116 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest001, TestSize.Level1)
117 {
118 ASSERT_NE(nullptr, g_powerInterface);
119 }
120
121 /**
122 * @tc.name: HdfPowerHdiTest002
123 * @tc.desc: RegisterCallback
124 * @tc.type: FUNC
125 */
126 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest002, TestSize.Level1)
127 {
128 if (false) {
129 EXPECT_TRUE(HDF_SUCCESS ==
130 g_powerInterface->RegisterCallback(g_callback))<< "HdfPowerHdiTest002 failed";
131 }
132 }
133
134 /**
135 * @tc.name: HdfPowerHdiTest003
136 * @tc.desc: check startsuspend
137 * @tc.type: FUNC
138 */
139 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest003, TestSize.Level1)
140 {
141 if (false) {
142 int32_t ret = g_powerInterface->StartSuspend();
143 EXPECT_EQ(0, ret);
144
145 char stateBuf[MAX_PATH] = {0};
146 char stateValue[MAX_PATH] = {0};
147
148 ret = snprintf_s(stateBuf, MAX_PATH, sizeof(stateBuf) - 1, SUSPEND_STATE_PATH.c_str());
149 EXPECT_FALSE(ret < EOK);
150 sleep(WAIT_TIME);
151 ret = HdfPowerHdiTest::ReadFile(stateBuf, stateValue, sizeof(stateValue));
152 EXPECT_EQ(0, ret);
153 std::string state = stateValue;
154 EXPECT_FALSE(state.empty());
155 auto pos = state.find(SUSPEND_STATE);
156 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest003 failed state: " << state;
157 }
158 }
159
160 /**
161 * @tc.name: HdfPowerHdiTest004
162 * @tc.desc: check StopSuspend
163 * @tc.type: FUNC
164 */
165 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest004, TestSize.Level1)
166 {
167 int32_t ret = g_powerInterface->StopSuspend();
168 EXPECT_EQ(0, ret) << "HdfPowerHdiTest004 failed";
169 }
170
171 /**
172 * @tc.name: HdfPowerHdiTest005
173 * @tc.desc: Force Suspend
174 * @tc.type: FUNC
175 */
176 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest005, TestSize.Level1)
177 {
178 if (false) {
179 int32_t ret = g_powerInterface->ForceSuspend();
180 EXPECT_EQ(0, ret) << "HdfPowerHdiTest005 failed";
181 }
182 }
183
184 /**
185 * @tc.name: HdfPowerHdiTest006
186 * @tc.desc: check SuspendBlock
187 * @tc.type: FUNC
188 */
189 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest006, TestSize.Level1)
190 {
191 std::string testName = "HdfPowerHdiTest006";
192 g_powerInterface->SuspendUnblock(testName);
193 sleep(WAIT_TIME);
194 int32_t ret = g_powerInterface->SuspendBlock(testName);
195 EXPECT_EQ(0, ret);
196
197 char lockBuf[MAX_PATH] = {0};
198 char lockValue[MAX_PATH] = {0};
199
200 ret = snprintf_s(lockBuf, MAX_PATH, sizeof(lockBuf) - 1, LOCK_PATH.c_str());
201 EXPECT_FALSE(ret < EOK);
202
203 sleep(WAIT_TIME);
204 ret = HdfPowerHdiTest::ReadFile(lockBuf, lockValue, sizeof(lockValue));
205 EXPECT_EQ(0, ret);
206 std::string lock = lockValue;
207 EXPECT_FALSE(lock.empty());
208 auto pos = lock.find(testName);
209 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest006 failed lock: " << lock;
210 }
211
212 /**
213 * @tc.name: HdfPowerHdiTest007
214 * @tc.desc: check SuspendUnblock
215 * @tc.type: FUNC
216 */
217 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest007, TestSize.Level1)
218 {
219 std::string testName = "HdfPowerHdiTest007";
220 g_powerInterface->SuspendBlock(testName);
221 sleep(WAIT_TIME);
222 int32_t ret = g_powerInterface->SuspendUnblock(testName);
223 EXPECT_EQ(0, ret);
224
225 char unLockBuf[MAX_PATH] = {0};
226 char unLockValue[MAX_PATH] = {0};
227
228 ret = snprintf_s(unLockBuf, MAX_PATH, sizeof(unLockBuf) - 1, UNLOCK_PATH.c_str());
229 EXPECT_FALSE(ret < EOK);
230
231 sleep(WAIT_TIME);
232 ret = HdfPowerHdiTest::ReadFile(unLockBuf, unLockValue, sizeof(unLockValue));
233 EXPECT_EQ(0, ret);
234 std::string unLock = unLockValue;
235 EXPECT_FALSE(unLock.empty());
236 auto pos = unLock.find(testName);
237 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest007 failed unLock: " << unLock;
238 }
239
240 /**
241 * @tc.name: HdfPowerHdiTest007
242 * @tc.desc: PowerDump
243 * @tc.type: FUNC
244 */
245 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest008, TestSize.Level1)
246 {
247 if (false) {
248 std::string dump;
249 EXPECT_TRUE(HDF_SUCCESS ==
250 g_powerInterface->PowerDump(dump))<< "HdfPowerHdiTest008 failed";
251 }
252 }
253 }
254