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