1 /*
2 * Copyright (c) 2022-2024 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_2/ipower_interface.h"
29 #include "v1_2/ipower_hdi_callback.h"
30 #include "v1_2/ipower_running_lock_callback.h"
31 #include "v1_2/power_types.h"
32 #include "v1_2/running_lock_types.h"
33
34 using namespace OHOS::HDI;
35 using namespace OHOS::HDI::Power::V1_2;
36 using namespace testing::ext;
37
38 namespace {
39 class PowerHdiCallback : public IPowerHdiCallback {
40 public:
~PowerHdiCallback()41 ~PowerHdiCallback() override {};
OnSuspend()42 int32_t OnSuspend() override
43 {
44 return 0;
45 };
46
OnWakeup()47 int32_t OnWakeup() override
48 {
49 return 0;
50 };
51 };
52
53 class PowerRunningLockCallback : public IPowerRunningLockCallback {
~PowerRunningLockCallback()54 ~PowerRunningLockCallback() override {};
HandleRunningLockMessage(const std::string & message)55 int32_t HandleRunningLockMessage(const std::string& message) override
56 {
57 (void)message;
58 return 0;
59 }
60 };
61
62 class PowerMockInterfaceImpl : public IPowerInterface {
63 public:
~PowerMockInterfaceImpl()64 ~PowerMockInterfaceImpl() override {};
65
RegisterCallback(const sptr<IPowerHdiCallback> & ipowerHdiCallback)66 int32_t RegisterCallback(const sptr<IPowerHdiCallback> &ipowerHdiCallback) override
67 {
68 (void)ipowerHdiCallback;
69 return 0;
70 }
71
SetSuspendTag(const std::string & tag)72 int32_t SetSuspendTag(const std::string& tag) override
73 {
74 return 0;
75 }
76
StartSuspend()77 int32_t StartSuspend() override
78 {
79 return 0;
80 }
81
StopSuspend()82 int32_t StopSuspend() override
83 {
84 return 0;
85 }
86
ForceSuspend()87 int32_t ForceSuspend() override
88 {
89 return 0;
90 }
91
Hibernate()92 int32_t Hibernate() override
93 {
94 return 0;
95 }
96
SuspendBlock(const std::string & name)97 int32_t SuspendBlock(const std::string &name) override
98 {
99 (void)name;
100 return 0;
101 }
102
SuspendUnblock(const std::string & name)103 int32_t SuspendUnblock(const std::string &name) override
104 {
105 (void)name;
106 return 0;
107 }
108
PowerDump(std::string & info)109 int32_t PowerDump(std::string &info) override
110 {
111 (void)info;
112 return 0;
113 }
114
HoldRunningLock(const RunningLockInfo & info)115 int32_t HoldRunningLock(const RunningLockInfo &info) override
116 {
117 (void)info;
118 return 0;
119 }
120
UnholdRunningLock(const RunningLockInfo & info)121 int32_t UnholdRunningLock(const RunningLockInfo &info) override
122 {
123 (void)info;
124 return 0;
125 }
126
GetWakeupReason(std::string & reason)127 int32_t GetWakeupReason(std::string &reason) override
128 {
129 (void)reason;
130 return 0;
131 }
132
RegisterRunningLockCallback(const sptr<IPowerRunningLockCallback> & iPowerRunningLockCallback)133 int32_t RegisterRunningLockCallback(const sptr<IPowerRunningLockCallback>
134 &iPowerRunningLockCallback) override
135 {
136 (void)iPowerRunningLockCallback;
137 return 0;
138 }
139
UnRegisterRunningLockCallback()140 int32_t UnRegisterRunningLockCallback() override
141 {
142 return 0;
143 }
144
HoldRunningLockExt(const RunningLockInfo & info,uint64_t lockid,const std::string & bundleName)145 int32_t HoldRunningLockExt(const RunningLockInfo &info, uint64_t lockid,
146 const std::string &bundleName) override
147 {
148 (void)info;
149 (void)lockid;
150 (void)bundleName;
151 return 0;
152 }
153
UnholdRunningLockExt(const RunningLockInfo & info,uint64_t lockid,const std::string & bundleName)154 int32_t UnholdRunningLockExt(const RunningLockInfo &info, uint64_t lockid,
155 const std::string &bundleName) override
156 {
157 (void)info;
158 (void)lockid;
159 (void)bundleName;
160 return 0;
161 }
162
SetPowerConfig(const std::string & scene,const std::string & value)163 int32_t SetPowerConfig(const std::string &scene, const std::string &value) override
164 {
165 (void)scene;
166 (void)value;
167 return 0;
168 }
169
GetPowerConfig(const std::string & scene,std::string & value)170 int32_t GetPowerConfig(const std::string &scene, std::string &value) override
171 {
172 (void)scene;
173 (void)value;
174 return 0;
175 }
176 };
177
178 sptr<IPowerHdiCallback> g_callback = new PowerHdiCallback();
179 sptr<IPowerRunningLockCallback> g_runningLockcallback = new PowerRunningLockCallback();
180 sptr<IPowerInterface> g_powerInterface = nullptr;
181 sptr<IPowerInterface> powerInterface = nullptr;
182 std::mutex g_mutex;
183 const uint32_t MAX_PATH = 256;
184 const uint32_t MAX_FILE = 1024;
185 const uint32_t WAIT_TIME = 1;
186 const std::string SUSPEND_STATE = "mem";
187 const std::string SUSPEND_STATE_PATH = "/sys/power/state";
188 const std::string LOCK_PATH = "/sys/power/wake_lock";
189 const std::string UNLOCK_PATH = "/sys/power/wake_unlock";
190 const std::string WAKEUP_COUNT_PATH = "/sys/power/wakeup_count";
191
192 class HdfPowerHdiTest : public testing::Test {
193 public:
194 static void SetUpTestCase();
195 static void TearDownTestCase();
196 void SetUp();
197 void TearDown();
198 static int32_t ReadFile(const char *path, char *buf, size_t size);
199 };
200
SetUpTestCase()201 void HdfPowerHdiTest::SetUpTestCase()
202 {
203 g_powerInterface = IPowerInterface::Get(true);
204 powerInterface = new PowerMockInterfaceImpl();
205 }
206
TearDownTestCase()207 void HdfPowerHdiTest::TearDownTestCase()
208 {
209 }
210
SetUp()211 void HdfPowerHdiTest::SetUp()
212 {
213 }
214
TearDown()215 void HdfPowerHdiTest::TearDown()
216 {
217 }
218
ReadFile(const char * path,char * buf,size_t size)219 int32_t HdfPowerHdiTest::ReadFile(const char *path, char *buf, size_t size)
220 {
221 std::lock_guard<std::mutex> lock(g_mutex);
222 int32_t ret;
223
224 int32_t fd = open(path, O_RDONLY, S_IRUSR | S_IRGRP | S_IROTH);
225 if (fd < HDF_SUCCESS) {
226 return HDF_FAILURE;
227 }
228
229 ret = read(fd, buf, size);
230 if (ret < HDF_SUCCESS) {
231 close(fd);
232 return HDF_FAILURE;
233 }
234
235 close(fd);
236 buf[size - 1] = '\0';
237 return HDF_SUCCESS;
238 }
239 }
240
241 namespace {
242 /**
243 * @tc.name: HdfPowerHdiTest001
244 * @tc.desc: Get a client and check whether the client is empty.
245 * @tc.type: FUNC
246 */
247 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest001, TestSize.Level1)
248 {
249 ASSERT_NE(nullptr, g_powerInterface);
250 }
251
252 /**
253 * @tc.name: HdfPowerHdiTest002
254 * @tc.desc: RegisterCallback
255 * @tc.type: FUNC
256 */
257 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest002, TestSize.Level1)
258 {
259 EXPECT_TRUE(HDF_SUCCESS ==
260 powerInterface->RegisterCallback(g_callback))<< "HdfPowerHdiTest002 failed";
261 }
262
263 /**
264 * @tc.name: HdfPowerHdiTest003
265 * @tc.desc: check startsuspend
266 * @tc.type: FUNC
267 */
268 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest003, TestSize.Level1)
269 {
270 int32_t ret = g_powerInterface->StartSuspend();
271 EXPECT_EQ(0, ret);
272
273 char stateBuf[MAX_PATH] = {0};
274 char stateValue[MAX_PATH] = {0};
275
276 ret = snprintf_s(stateBuf, MAX_PATH, sizeof(stateBuf) - 1, SUSPEND_STATE_PATH.c_str());
277 EXPECT_FALSE(ret < EOK);
278 sleep(WAIT_TIME);
279 ret = HdfPowerHdiTest::ReadFile(stateBuf, stateValue, sizeof(stateValue));
280 EXPECT_EQ(0, ret);
281 std::string state = stateValue;
282 EXPECT_FALSE(state.empty());
283 auto pos = state.find(SUSPEND_STATE);
284 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest003 failed state: " << state;
285 }
286
287 /**
288 * @tc.name: HdfPowerHdiTest004
289 * @tc.desc: check StopSuspend
290 * @tc.type: FUNC
291 */
292 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest004, TestSize.Level1)
293 {
294 int32_t ret = g_powerInterface->StopSuspend();
295 EXPECT_EQ(0, ret) << "HdfPowerHdiTest004 failed";
296 }
297
298 /**
299 * @tc.name: HdfPowerHdiTest005
300 * @tc.desc: Force Suspend
301 * @tc.type: FUNC
302 */
303 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest005, TestSize.Level1)
304 {
305 int32_t ret = powerInterface->ForceSuspend();
306 EXPECT_EQ(0, ret) << "HdfPowerHdiTest005 failed";
307 }
308
309 /**
310 * @tc.name: HdfPowerHdiTest006
311 * @tc.desc: check SuspendBlock
312 * @tc.type: FUNC
313 */
314 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest006, TestSize.Level1)
315 {
316 std::string testName = "HdfPowerHdiTest006";
317 g_powerInterface->SuspendUnblock(testName);
318 sleep(WAIT_TIME);
319 int32_t ret = g_powerInterface->SuspendBlock(testName);
320 EXPECT_EQ(0, ret);
321
322 char lockBuf[MAX_PATH] = {0};
323 char lockValue[MAX_FILE] = {0};
324
325 ret = snprintf_s(lockBuf, MAX_PATH, sizeof(lockBuf) - 1, LOCK_PATH.c_str());
326 EXPECT_FALSE(ret < EOK);
327
328 sleep(WAIT_TIME);
329 ret = HdfPowerHdiTest::ReadFile(lockBuf, lockValue, sizeof(lockValue));
330 EXPECT_EQ(0, ret);
331 std::string lock = lockValue;
332 EXPECT_FALSE(lock.empty());
333 auto pos = lock.find(testName);
334 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest006 failed lock: " << lock;
335 }
336
337 /**
338 * @tc.name: HdfPowerHdiTest007
339 * @tc.desc: check SuspendUnblock
340 * @tc.type: FUNC
341 */
342 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest007, TestSize.Level1)
343 {
344 std::string testName = "HdfPowerHdiTest007";
345 g_powerInterface->SuspendBlock(testName);
346 sleep(WAIT_TIME);
347 int32_t ret = g_powerInterface->SuspendUnblock(testName);
348 EXPECT_EQ(0, ret);
349
350 char unLockBuf[MAX_PATH] = {0};
351 char unLockValue[MAX_PATH] = {0};
352
353 ret = snprintf_s(unLockBuf, MAX_PATH, sizeof(unLockBuf) - 1, UNLOCK_PATH.c_str());
354 EXPECT_FALSE(ret < EOK);
355
356 sleep(WAIT_TIME);
357 ret = HdfPowerHdiTest::ReadFile(unLockBuf, unLockValue, sizeof(unLockValue));
358 EXPECT_EQ(0, ret);
359 std::string unLock = unLockValue;
360 EXPECT_FALSE(unLock.empty());
361 auto pos = unLock.find(testName);
362 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest007 failed unLock: " << unLock;
363 }
364
365 /**
366 * @tc.name: HdfPowerHdiTest008
367 * @tc.desc: PowerDump
368 * @tc.type: FUNC
369 */
370 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest008, TestSize.Level1)
371 {
372 std::string dump;
373 EXPECT_TRUE(HDF_SUCCESS ==
374 g_powerInterface->PowerDump(dump))<< "HdfPowerHdiTest008 failed";
375 }
376
377 /**
378 * @tc.name: HdfPowerHdiTest009
379 * @tc.desc: HoldRunningLock
380 * @tc.type: FUNC
381 */
382 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest009, TestSize.Level1)
383 {
384 struct RunningLockInfo info = {
385 .name = "acts_test",
386 .type = RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE,
387 .timeoutMs = 3000,
388 .pid = 0,
389 .uid = 0,
390 };
391 int32_t ret = g_powerInterface->HoldRunningLock(info);
392 EXPECT_TRUE(HDF_SUCCESS == ret) << "HdfPowerHdiTest009 failed";
393 }
394
395 /**
396 * @tc.name: HdfPowerHdiTest010
397 * @tc.desc: HoldRunningLock, name is null
398 * @tc.type: FUNC
399 */
400 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest010, TestSize.Level1)
401 {
402 struct RunningLockInfo info = {
403 .name = "",
404 .type = RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE,
405 .timeoutMs = 3000,
406 .pid = 0,
407 .uid = 0,
408 };
409 int32_t ret = g_powerInterface->HoldRunningLock(info);
410 EXPECT_TRUE(HDF_ERR_INVALID_PARAM == ret) << "HdfPowerHdiTest010 failed";
411 }
412
413 /**
414 * @tc.name: HdfPowerHdiTest011
415 * @tc.desc: HoldRunningLock, type is invaild
416 * @tc.type: FUNC
417 */
418 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest011, TestSize.Level1)
419 {
420 struct RunningLockInfo info = {
421 .name = "acts_test",
422 .type = static_cast<RunningLockType>(100),
423 .timeoutMs = 3000,
424 .pid = 0,
425 .uid = 0,
426 };
427 int32_t ret = g_powerInterface->HoldRunningLock(info);
428 EXPECT_TRUE(HDF_ERR_INVALID_PARAM == ret) << "HdfPowerHdiTest011 failed";
429 }
430
431 /**
432 * @tc.name: HdfPowerHdiTest012
433 * @tc.desc: UnholdRunningLock, name is null
434 * @tc.type: FUNC
435 */
436 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest012, TestSize.Level1)
437 {
438 struct RunningLockInfo info = {
439 .name = "",
440 };
441 int32_t ret = g_powerInterface->UnholdRunningLock(info);
442 EXPECT_TRUE(HDF_ERR_INVALID_PARAM == ret) << "HdfPowerHdiTest012 failed";
443 }
444
445 /**
446 * @tc.name: HdfPowerHdiTest013
447 * @tc.desc: UnholdRunningLock, type is invaild
448 * @tc.type: FUNC
449 */
450 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest013, TestSize.Level1)
451 {
452 struct RunningLockInfo info = {
453 .name = "acts_test",
454 .type = static_cast<RunningLockType>(100),
455 };
456 int32_t ret = g_powerInterface->UnholdRunningLock(info);
457 EXPECT_TRUE(HDF_ERR_INVALID_PARAM == ret) << "HdfPowerHdiTest013 failed";
458 }
459
460 /**
461 * @tc.name: HdfPowerHdiTest014
462 * @tc.desc: UnholdRunningLock, runninglock type not found
463 * @tc.type: FUNC
464 */
465 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest014, TestSize.Level1)
466 {
467 struct RunningLockInfo info = {
468 .name = "acts_test",
469 .type = RunningLockType::RUNNINGLOCK_BACKGROUND_TASK,
470 };
471 int32_t ret = g_powerInterface->UnholdRunningLock(info);
472 EXPECT_TRUE(HDF_ERR_NOT_SUPPORT == ret) << "HdfPowerHdiTest014 failed";
473 }
474
475 /**
476 * @tc.name: HdfPowerHdiTest015
477 * @tc.desc: UnholdRunningLock, runninglock name not found
478 * @tc.type: FUNC
479 */
480 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest015, TestSize.Level1)
481 {
482 struct RunningLockInfo info = {
483 .name = "",
484 .type = RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION,
485 .timeoutMs = -1,
486 .pid = 0,
487 .uid = 0,
488 };
489 std::string lockName = "acts_test";
490 std::string errorLockName = "error_acts_test";
491
492 info.name = lockName;
493 int32_t ret = g_powerInterface->HoldRunningLock(info);
494 EXPECT_TRUE(HDF_SUCCESS == ret);
495 info.name = errorLockName;
496 ret = g_powerInterface->UnholdRunningLock(info);
497 EXPECT_TRUE(HDF_ERR_NOT_SUPPORT == ret);
498 info.name = lockName;
499 ret = g_powerInterface->UnholdRunningLock(info);
500 EXPECT_TRUE(HDF_SUCCESS == ret);
501 }
502
503 /**
504 * @tc.name: HdfPowerHdiTest016
505 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
506 * @tc.type: FUNC
507 */
508 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest016, TestSize.Level3)
509 {
510 printf("HdfPowerHdiTest016: start.");
511 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCmd::CMD_REGISTER_CALLBCK == 0);
512 printf("HdfPowerHdiTest016: end.");
513 }
514
515 /**
516 * @tc.name: HdfPowerHdiTest017
517 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
518 * @tc.type: FUNC
519 */
520 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest017, TestSize.Level3)
521 {
522 printf("HdfPowerHdiTest017: start.");
523 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCmd::CMD_START_SUSPEND == 1);
524 printf("HdfPowerHdiTest017: end.");
525 }
526
527 /**
528 * @tc.name: HdfPowerHdiTest018
529 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
530 * @tc.type: FUNC
531 */
532 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest018, TestSize.Level3)
533 {
534 printf("HdfPowerHdiTest018: start.");
535 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCmd::CMD_STOP_SUSPEND == 2);
536 printf("HdfPowerHdiTest018: end.");
537 }
538
539 /**
540 * @tc.name: HdfPowerHdiTest019
541 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
542 * @tc.type: FUNC
543 */
544 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest019, TestSize.Level3)
545 {
546 printf("HdfPowerHdiTest019: start.");
547 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCmd::CMD_FORCE_SUSPEND == 3);
548 printf("HdfPowerHdiTest019: end.");
549 }
550
551 /**
552 * @tc.name: HdfPowerHdiTest020
553 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
554 * @tc.type: FUNC
555 */
556 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest020, TestSize.Level3)
557 {
558 printf("HdfPowerHdiTest020: start.");
559 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCmd::CMD_SUSPEND_BLOCK == 4);
560 printf("HdfPowerHdiTest020: end.");
561 }
562
563 /**
564 * @tc.name: HdfPowerHdiTest021
565 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
566 * @tc.type: FUNC
567 */
568 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest021, TestSize.Level3)
569 {
570 printf("HdfPowerHdiTest021: start.");
571 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCmd::CMD_SUSPEND_UNBLOCK == 5);
572 printf("HdfPowerHdiTest021: end.");
573 }
574
575 /**
576 * @tc.name: HdfPowerHdiTest022
577 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
578 * @tc.type: FUNC
579 */
580 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest022, TestSize.Level3)
581 {
582 printf("HdfPowerHdiTest022: start.");
583 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCmd::CMD_DUMP == 6);
584 printf("HdfPowerHdiTest022: end.");
585 }
586
587 /**
588 * @tc.name: HdfPowerHdiTest023
589 * @tc.desc: Judgment PowerHdfCallbackCmd enum value of the PowerTypes.idl
590 * @tc.type: FUNC
591 */
592 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest023, TestSize.Level3)
593 {
594 printf("HdfPowerHdiTest023: start.");
595 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCallbackCmd::CMD_ON_SUSPEND == 0);
596 printf("HdfPowerHdiTest023: end.");
597 }
598
599 /**
600 * @tc.name: HdfPowerHdiTest024
601 * @tc.desc: Judgment PowerHdfCallbackCmd enum value of the PowerTypes.idl
602 * @tc.type: FUNC
603 */
604 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest024, TestSize.Level3)
605 {
606 printf("HdfPowerHdiTest024: start.");
607 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfCallbackCmd::CMD_ON_WAKEUP == 1);
608 printf("HdfPowerHdiTest024: end.");
609 }
610
611 /**
612 * @tc.name: HdfPowerHdiTest025
613 * @tc.desc: Judgment PowerHdfState enum value of the PowerTypes.idl
614 * @tc.type: FUNC
615 */
616 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest025, TestSize.Level3)
617 {
618 printf("HdfPowerHdiTest025: start.");
619 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfState::AWAKE == 0);
620 printf("HdfPowerHdiTest025: end.");
621 }
622
623 /**
624 * @tc.name: HdfPowerHdiTest026
625 * @tc.desc: Judgment PowerHdfState enum value of the PowerTypes.idl
626 * @tc.type: FUNC
627 */
628 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest026, TestSize.Level3)
629 {
630 printf("HdfPowerHdiTest026: start.");
631 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfState::INACTIVE == 1);
632 printf("HdfPowerHdiTest026: end.");
633 }
634
635 /**
636 * @tc.name: HdfPowerHdiTest027
637 * @tc.desc: Judgment PowerHdfState enum value of the PowerTypes.idl
638 * @tc.type: FUNC
639 */
640 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest027, TestSize.Level3)
641 {
642 printf("HdfPowerHdiTest027: start.");
643 EXPECT_TRUE(OHOS::HDI::Power::V1_2::PowerHdfState::SLEEP == 2);
644 printf("HdfPowerHdiTest027: end.");
645 }
646
647 /**
648 * @tc.name: HdfPowerHdiTest028
649 * @tc.desc: Judgment BaseRunningLockType enum value of the RunningLockTypes.idl
650 * @tc.type: FUNC
651 */
652 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest028, TestSize.Level3)
653 {
654 printf("HdfPowerHdiTest028: start.");
655 EXPECT_TRUE(OHOS::HDI::Power::V1_2::BaseRunningLockType::RUNNINGLOCK_SCREEN == 0);
656 printf("HdfPowerHdiTest028: end.");
657 }
658
659 /**
660 * @tc.name: HdfPowerHdiTest029
661 * @tc.desc: Judgment BaseRunningLockType enum value of the RunningLockTypes.idl
662 * @tc.type: FUNC
663 */
664 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest029, TestSize.Level3)
665 {
666 printf("HdfPowerHdiTest029: start.");
667 EXPECT_TRUE(OHOS::HDI::Power::V1_2::BaseRunningLockType::RUNNINGLOCK_BACKGROUND == 1);
668 printf("HdfPowerHdiTest029: end.");
669 }
670
671 /**
672 * @tc.name: HdfPowerHdiTest030
673 * @tc.desc: Judgment BaseRunningLockType enum value of the RunningLockTypes.idl
674 * @tc.type: FUNC
675 */
676 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest030, TestSize.Level3)
677 {
678 printf("HdfPowerHdiTest030: start.");
679 EXPECT_TRUE(OHOS::HDI::Power::V1_2::BaseRunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL == 2);
680 printf("HdfPowerHdiTest030: end.");
681 }
682
683 /**
684 * @tc.name: HdfPowerHdiTest031
685 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
686 * @tc.type: FUNC
687 */
688 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest031, TestSize.Level3)
689 {
690 printf("HdfPowerHdiTest031: start.");
691 EXPECT_TRUE(OHOS::HDI::Power::V1_2::RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE == 3);
692 printf("HdfPowerHdiTest031: end.");
693 }
694
695 /**
696 * @tc.name: HdfPowerHdiTest032
697 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
698 * @tc.type: FUNC
699 */
700 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest032, TestSize.Level3)
701 {
702 printf("HdfPowerHdiTest032: start.");
703 EXPECT_TRUE(OHOS::HDI::Power::V1_2::RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION == 5);
704 printf("HdfPowerHdiTest032: end.");
705 }
706
707 /**
708 * @tc.name: HdfPowerHdiTest033
709 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
710 * @tc.type: FUNC
711 */
712 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest033, TestSize.Level3)
713 {
714 printf("HdfPowerHdiTest033: start.");
715 EXPECT_TRUE(OHOS::HDI::Power::V1_2::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO == 9);
716 printf("HdfPowerHdiTest033: end.");
717 }
718
719 /**
720 * @tc.name: HdfPowerHdiTest034
721 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
722 * @tc.type: FUNC
723 */
724 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest034, TestSize.Level3)
725 {
726 printf("HdfPowerHdiTest034: start.");
727 EXPECT_TRUE(OHOS::HDI::Power::V1_2::RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT == 17);
728 printf("HdfPowerHdiTest034: end.");
729 }
730
731 /**
732 * @tc.name: HdfPowerHdiTest035
733 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
734 * @tc.type: FUNC
735 */
736 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest035, TestSize.Level3)
737 {
738 printf("HdfPowerHdiTest035: start.");
739 EXPECT_TRUE(OHOS::HDI::Power::V1_2::RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION == 33);
740 printf("HdfPowerHdiTest035: end.");
741 }
742
743 /**
744 * @tc.name: HdfPowerHdiTest036
745 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
746 * @tc.type: FUNC
747 */
748 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest036, TestSize.Level3)
749 {
750 printf("HdfPowerHdiTest036: start.");
751 EXPECT_TRUE(OHOS::HDI::Power::V1_2::RunningLockType::RUNNINGLOCK_BACKGROUND_TASK == 65);
752 printf("HdfPowerHdiTest036: end.");
753 }
754
755 /**
756 * @tc.name: HdfPowerHdiTest037
757 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
758 * @tc.type: FUNC
759 */
760 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest037, TestSize.Level3)
761 {
762 printf("HdfPowerHdiTest037: start.");
763 EXPECT_TRUE(OHOS::HDI::Power::V1_2::RunningLockType::RUNNINGLOCK_BUTT == 66);
764 printf("HdfPowerHdiTest037: end.");
765 }
766
767 /**
768 * @tc.name: HdfPowerHdiTest038
769 * @tc.desc: check GetWakeupReason
770 * @tc.type: FUNC
771 */
772 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest038, TestSize.Level1)
773 {
774 std::string testName = "HdfPowerHdiTest038";
775 int32_t ret = g_powerInterface->GetWakeupReason(testName);
776 if (ret == 0) {
777 EXPECT_EQ(0, ret);
778 } else {
779 EXPECT_NE(0, ret);
780 }
781 }
782
783 /**
784 * @tc.name: HdfPowerHdiTest039
785 * @tc.desc: RegisterRunningLockCallback
786 * @tc.type: FUNC
787 */
788 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest039, TestSize.Level1)
789 {
790 EXPECT_TRUE(HDF_SUCCESS ==
791 powerInterface->RegisterRunningLockCallback(g_runningLockcallback))<< "HdfPowerHdiTest039 failed";
792 EXPECT_TRUE(HDF_SUCCESS ==
793 g_runningLockcallback->HandleRunningLockMessage(""))<< "HdfPowerHdiTest039 failed";
794 }
795
796 /**
797 * @tc.name: HdfPowerHdiTest040
798 * @tc.desc: Hibernate
799 * @tc.type: FUNC
800 */
801 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest040, TestSize.Level1)
802 {
803 int32_t ret = powerInterface->Hibernate();
804 EXPECT_EQ(0, ret) << "HdfPowerHdiTest040 failed";
805 }
806
807 /**
808 * @tc.name: HdfPowerHdiTest041
809 * @tc.desc: SetSuspendTag
810 * @tc.type: FUNC
811 */
812 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest041, TestSize.Level1)
813 {
814 int32_t ret = powerInterface->SetSuspendTag("");
815 EXPECT_EQ(0, ret) << "HdfPowerHdiTest041 failed";
816 }
817
818 /**
819 * @tc.name: HdfPowerHdiTest042
820 * @tc.desc: check SetPowerConfig
821 * @tc.type: FUNC
822 */
823 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest042, TestSize.Level1)
824 {
825 std::string sceneName = "PowerConfigTestScene";
826 std::string value = "";
827 int32_t result = g_powerInterface->SetPowerConfig(sceneName, value);
828 EXPECT_EQ(true, result != 0);
829 }
830
831 /**
832 * @tc.name: HdfPowerHdiTest043
833 * @tc.desc: check GetPowerConfig
834 * @tc.type: FUNC
835 */
836 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest043, TestSize.Level1)
837 {
838 std::string sceneName = "PowerConfigTestScene";
839 std::string value = "";
840 int32_t result = g_powerInterface->GetPowerConfig(sceneName, value);
841 EXPECT_EQ(true, value == "");
842 EXPECT_EQ(true, result != 0);
843 }
844 }
845