1 /*
2 * Copyright (c) 2022-2023 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_1/ipower_interface.h"
29 #include "v1_1/ipower_hdi_callback.h"
30 #include "v1_1/power_types.h"
31 #include "v1_1/running_lock_types.h"
32
33 using namespace OHOS::HDI;
34 using namespace OHOS::HDI::Power::V1_1;
35 using namespace testing::ext;
36
37 namespace {
38 class PowerHdiCallback : public IPowerHdiCallback {
39 public:
~PowerHdiCallback()40 ~PowerHdiCallback() override {};
OnSuspend()41 int32_t OnSuspend() override
42 {
43 return 0;
44 };
45
OnWakeup()46 int32_t OnWakeup() override
47 {
48 return 0;
49 };
50 };
51
52 sptr<IPowerHdiCallback> g_callback = new PowerHdiCallback();
53 sptr<IPowerInterface> g_powerInterface = nullptr;
54 std::mutex g_mutex;
55 const uint32_t MAX_PATH = 256;
56 const uint32_t WAIT_TIME = 1;
57 const std::string SUSPEND_STATE = "mem";
58 const std::string SUSPEND_STATE_PATH = "/sys/power/state";
59 const std::string LOCK_PATH = "/sys/power/wake_lock";
60 const std::string UNLOCK_PATH = "/sys/power/wake_unlock";
61 const std::string WAKEUP_COUNT_PATH = "/sys/power/wakeup_count";
62
63 class HdfPowerHdiTest : public testing::Test {
64 public:
65 static void SetUpTestCase();
66 static void TearDownTestCase();
67 void SetUp();
68 void TearDown();
69 static int32_t ReadFile(const char *path, char *buf, size_t size);
70 };
71
SetUpTestCase()72 void HdfPowerHdiTest::SetUpTestCase()
73 {
74 g_powerInterface = IPowerInterface::Get(true);
75 }
76
TearDownTestCase()77 void HdfPowerHdiTest::TearDownTestCase()
78 {
79 }
80
SetUp()81 void HdfPowerHdiTest::SetUp()
82 {
83 }
84
TearDown()85 void HdfPowerHdiTest::TearDown()
86 {
87 }
88
ReadFile(const char * path,char * buf,size_t size)89 int32_t HdfPowerHdiTest::ReadFile(const char *path, char *buf, size_t size)
90 {
91 std::lock_guard<std::mutex> lock(g_mutex);
92 int32_t ret;
93
94 int32_t fd = open(path, O_RDONLY, S_IRUSR | S_IRGRP | S_IROTH);
95 if (fd < HDF_SUCCESS) {
96 return HDF_FAILURE;
97 }
98
99 ret = read(fd, buf, size);
100 if (ret < HDF_SUCCESS) {
101 close(fd);
102 return HDF_FAILURE;
103 }
104
105 close(fd);
106 buf[size - 1] = '\0';
107 return HDF_SUCCESS;
108 }
109 }
110
111 namespace {
112 /**
113 * @tc.name: HdfPowerHdiTest001
114 * @tc.desc: Get a client and check whether the client is empty.
115 * @tc.type: FUNC
116 */
117 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest001, TestSize.Level1)
118 {
119 ASSERT_NE(nullptr, g_powerInterface);
120 }
121
122 /**
123 * @tc.name: HdfPowerHdiTest002
124 * @tc.desc: RegisterCallback
125 * @tc.type: FUNC
126 */
127 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest002, TestSize.Level1)
128 {
129 if (false) {
130 EXPECT_TRUE(HDF_SUCCESS ==
131 g_powerInterface->RegisterCallback(g_callback))<< "HdfPowerHdiTest002 failed";
132 }
133 }
134
135 /**
136 * @tc.name: HdfPowerHdiTest003
137 * @tc.desc: check startsuspend
138 * @tc.type: FUNC
139 */
140 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest003, TestSize.Level1)
141 {
142 if (false) {
143 int32_t ret = g_powerInterface->StartSuspend();
144 EXPECT_EQ(0, ret);
145
146 char stateBuf[MAX_PATH] = {0};
147 char stateValue[MAX_PATH] = {0};
148
149 ret = snprintf_s(stateBuf, MAX_PATH, sizeof(stateBuf) - 1, SUSPEND_STATE_PATH.c_str());
150 EXPECT_FALSE(ret < EOK);
151 sleep(WAIT_TIME);
152 ret = HdfPowerHdiTest::ReadFile(stateBuf, stateValue, sizeof(stateValue));
153 EXPECT_EQ(0, ret);
154 std::string state = stateValue;
155 EXPECT_FALSE(state.empty());
156 auto pos = state.find(SUSPEND_STATE);
157 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest003 failed state: " << state;
158 }
159 }
160
161 /**
162 * @tc.name: HdfPowerHdiTest004
163 * @tc.desc: check StopSuspend
164 * @tc.type: FUNC
165 */
166 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest004, TestSize.Level1)
167 {
168 int32_t ret = g_powerInterface->StopSuspend();
169 EXPECT_EQ(0, ret) << "HdfPowerHdiTest004 failed";
170 }
171
172 /**
173 * @tc.name: HdfPowerHdiTest005
174 * @tc.desc: Force Suspend
175 * @tc.type: FUNC
176 */
177 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest005, TestSize.Level1)
178 {
179 if (false) {
180 int32_t ret = g_powerInterface->ForceSuspend();
181 EXPECT_EQ(0, ret) << "HdfPowerHdiTest005 failed";
182 }
183 }
184
185 /**
186 * @tc.name: HdfPowerHdiTest006
187 * @tc.desc: check SuspendBlock
188 * @tc.type: FUNC
189 */
190 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest006, TestSize.Level1)
191 {
192 std::string testName = "HdfPowerHdiTest006";
193 g_powerInterface->SuspendUnblock(testName);
194 sleep(WAIT_TIME);
195 int32_t ret = g_powerInterface->SuspendBlock(testName);
196 EXPECT_EQ(0, ret);
197
198 char lockBuf[MAX_PATH] = {0};
199 char lockValue[MAX_PATH] = {0};
200
201 ret = snprintf_s(lockBuf, MAX_PATH, sizeof(lockBuf) - 1, LOCK_PATH.c_str());
202 EXPECT_FALSE(ret < EOK);
203
204 sleep(WAIT_TIME);
205 ret = HdfPowerHdiTest::ReadFile(lockBuf, lockValue, sizeof(lockValue));
206 EXPECT_EQ(0, ret);
207 std::string lock = lockValue;
208 EXPECT_FALSE(lock.empty());
209 auto pos = lock.find(testName);
210 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest006 failed lock: " << lock;
211 }
212
213 /**
214 * @tc.name: HdfPowerHdiTest007
215 * @tc.desc: check SuspendUnblock
216 * @tc.type: FUNC
217 */
218 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest007, TestSize.Level1)
219 {
220 std::string testName = "HdfPowerHdiTest007";
221 g_powerInterface->SuspendBlock(testName);
222 sleep(WAIT_TIME);
223 int32_t ret = g_powerInterface->SuspendUnblock(testName);
224 EXPECT_EQ(0, ret);
225
226 char unLockBuf[MAX_PATH] = {0};
227 char unLockValue[MAX_PATH] = {0};
228
229 ret = snprintf_s(unLockBuf, MAX_PATH, sizeof(unLockBuf) - 1, UNLOCK_PATH.c_str());
230 EXPECT_FALSE(ret < EOK);
231
232 sleep(WAIT_TIME);
233 ret = HdfPowerHdiTest::ReadFile(unLockBuf, unLockValue, sizeof(unLockValue));
234 EXPECT_EQ(0, ret);
235 std::string unLock = unLockValue;
236 EXPECT_FALSE(unLock.empty());
237 auto pos = unLock.find(testName);
238 EXPECT_TRUE(pos != std::string::npos) << "HdfPowerHdiTest007 failed unLock: " << unLock;
239 }
240
241 /**
242 * @tc.name: HdfPowerHdiTest008
243 * @tc.desc: PowerDump
244 * @tc.type: FUNC
245 */
246 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest008, TestSize.Level1)
247 {
248 if (false) {
249 std::string dump;
250 EXPECT_TRUE(HDF_SUCCESS ==
251 g_powerInterface->PowerDump(dump))<< "HdfPowerHdiTest008 failed";
252 }
253 }
254
255 /**
256 * @tc.name: HdfPowerHdiTest009
257 * @tc.desc: HoldRunningLock
258 * @tc.type: FUNC
259 */
260 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest009, TestSize.Level1)
261 {
262 struct RunningLockInfo info = {
263 .name = "acts_test",
264 .type = RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE,
265 .timeoutMs = 3000,
266 .pid = 0,
267 .uid = 0,
268 };
269 int32_t ret = g_powerInterface->HoldRunningLock(info);
270 EXPECT_TRUE(HDF_SUCCESS == ret) << "HdfPowerHdiTest009 failed";
271 }
272
273 /**
274 * @tc.name: HdfPowerHdiTest010
275 * @tc.desc: HoldRunningLock, name is null
276 * @tc.type: FUNC
277 */
278 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest010, TestSize.Level1)
279 {
280 struct RunningLockInfo info = {
281 .name = "",
282 .type = RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE,
283 .timeoutMs = 3000,
284 .pid = 0,
285 .uid = 0,
286 };
287 int32_t ret = g_powerInterface->HoldRunningLock(info);
288 EXPECT_TRUE(HDF_ERR_INVALID_PARAM == ret) << "HdfPowerHdiTest010 failed";
289 }
290
291 /**
292 * @tc.name: HdfPowerHdiTest011
293 * @tc.desc: HoldRunningLock, type is invaild
294 * @tc.type: FUNC
295 */
296 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest011, TestSize.Level1)
297 {
298 struct RunningLockInfo info = {
299 .name = "acts_test",
300 .type = static_cast<RunningLockType>(100),
301 .timeoutMs = 3000,
302 .pid = 0,
303 .uid = 0,
304 };
305 int32_t ret = g_powerInterface->HoldRunningLock(info);
306 EXPECT_TRUE(HDF_ERR_INVALID_PARAM == ret) << "HdfPowerHdiTest011 failed";
307 }
308
309 /**
310 * @tc.name: HdfPowerHdiTest012
311 * @tc.desc: UnholdRunningLock, name is null
312 * @tc.type: FUNC
313 */
314 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest012, TestSize.Level1)
315 {
316 struct RunningLockInfo info = {
317 .name = "",
318 };
319 int32_t ret = g_powerInterface->UnholdRunningLock(info);
320 EXPECT_TRUE(HDF_ERR_INVALID_PARAM == ret) << "HdfPowerHdiTest012 failed";
321 }
322
323 /**
324 * @tc.name: HdfPowerHdiTest013
325 * @tc.desc: UnholdRunningLock, type is invaild
326 * @tc.type: FUNC
327 */
328 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest013, TestSize.Level1)
329 {
330 struct RunningLockInfo info = {
331 .name = "acts_test",
332 .type = static_cast<RunningLockType>(100),
333 };
334 int32_t ret = g_powerInterface->UnholdRunningLock(info);
335 EXPECT_TRUE(HDF_ERR_INVALID_PARAM == ret) << "HdfPowerHdiTest013 failed";
336 }
337
338 /**
339 * @tc.name: HdfPowerHdiTest014
340 * @tc.desc: UnholdRunningLock, runninglock type not found
341 * @tc.type: FUNC
342 */
343 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest014, TestSize.Level1)
344 {
345 struct RunningLockInfo info = {
346 .name = "acts_test",
347 .type = RunningLockType::RUNNINGLOCK_BACKGROUND_TASK,
348 };
349 int32_t ret = g_powerInterface->UnholdRunningLock(info);
350 EXPECT_TRUE(HDF_ERR_NOT_SUPPORT == ret) << "HdfPowerHdiTest014 failed";
351 }
352
353 /**
354 * @tc.name: HdfPowerHdiTest015
355 * @tc.desc: UnholdRunningLock, runninglock name not found
356 * @tc.type: FUNC
357 */
358 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest015, TestSize.Level1)
359 {
360 struct RunningLockInfo info = {
361 .name = "",
362 .type = RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION,
363 .timeoutMs = -1,
364 .pid = 0,
365 .uid = 0,
366 };
367 std::string lockName = "acts_test";
368 std::string errorLockName = "error_acts_test";
369
370 info.name = lockName;
371 int32_t ret = g_powerInterface->HoldRunningLock(info);
372 EXPECT_TRUE(HDF_SUCCESS == ret);
373 info.name = errorLockName;
374 ret = g_powerInterface->UnholdRunningLock(info);
375 EXPECT_TRUE(HDF_ERR_NOT_SUPPORT == ret);
376 info.name = lockName;
377 ret = g_powerInterface->UnholdRunningLock(info);
378 EXPECT_TRUE(HDF_SUCCESS == ret);
379 }
380
381 /**
382 * @tc.name: HdfPowerHdiTest016
383 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
384 * @tc.type: FUNC
385 */
386 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest016, TestSize.Level3)
387 {
388 printf("HdfPowerHdiTest016: start.");
389 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCmd::CMD_REGISTER_CALLBCK == 0);
390 printf("HdfPowerHdiTest016: end.");
391 }
392
393 /**
394 * @tc.name: HdfPowerHdiTest017
395 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
396 * @tc.type: FUNC
397 */
398 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest017, TestSize.Level3)
399 {
400 printf("HdfPowerHdiTest017: start.");
401 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCmd::CMD_START_SUSPEND == 1);
402 printf("HdfPowerHdiTest017: end.");
403 }
404
405 /**
406 * @tc.name: HdfPowerHdiTest018
407 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
408 * @tc.type: FUNC
409 */
410 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest018, TestSize.Level3)
411 {
412 printf("HdfPowerHdiTest018: start.");
413 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCmd::CMD_STOP_SUSPEND == 2);
414 printf("HdfPowerHdiTest018: end.");
415 }
416
417 /**
418 * @tc.name: HdfPowerHdiTest019
419 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
420 * @tc.type: FUNC
421 */
422 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest019, TestSize.Level3)
423 {
424 printf("HdfPowerHdiTest019: start.");
425 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCmd::CMD_FORCE_SUSPEND == 3);
426 printf("HdfPowerHdiTest019: end.");
427 }
428
429 /**
430 * @tc.name: HdfPowerHdiTest020
431 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
432 * @tc.type: FUNC
433 */
434 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest020, TestSize.Level3)
435 {
436 printf("HdfPowerHdiTest020: start.");
437 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCmd::CMD_SUSPEND_BLOCK == 4);
438 printf("HdfPowerHdiTest020: end.");
439 }
440
441 /**
442 * @tc.name: HdfPowerHdiTest021
443 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
444 * @tc.type: FUNC
445 */
446 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest021, TestSize.Level3)
447 {
448 printf("HdfPowerHdiTest021: start.");
449 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCmd::CMD_SUSPEND_UNBLOCK == 5);
450 printf("HdfPowerHdiTest021: end.");
451 }
452
453 /**
454 * @tc.name: HdfPowerHdiTest022
455 * @tc.desc: Judgment PowerHdfCmd enum value of the PowerTypes.idl
456 * @tc.type: FUNC
457 */
458 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest022, TestSize.Level3)
459 {
460 printf("HdfPowerHdiTest022: start.");
461 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCmd::CMD_DUMP == 6);
462 printf("HdfPowerHdiTest022: end.");
463 }
464
465 /**
466 * @tc.name: HdfPowerHdiTest023
467 * @tc.desc: Judgment PowerHdfCallbackCmd enum value of the PowerTypes.idl
468 * @tc.type: FUNC
469 */
470 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest023, TestSize.Level3)
471 {
472 printf("HdfPowerHdiTest023: start.");
473 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCallbackCmd::CMD_ON_SUSPEND == 0);
474 printf("HdfPowerHdiTest023: end.");
475 }
476
477 /**
478 * @tc.name: HdfPowerHdiTest024
479 * @tc.desc: Judgment PowerHdfCallbackCmd enum value of the PowerTypes.idl
480 * @tc.type: FUNC
481 */
482 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest024, TestSize.Level3)
483 {
484 printf("HdfPowerHdiTest024: start.");
485 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfCallbackCmd::CMD_ON_WAKEUP == 1);
486 printf("HdfPowerHdiTest024: end.");
487 }
488
489 /**
490 * @tc.name: HdfPowerHdiTest025
491 * @tc.desc: Judgment PowerHdfState enum value of the PowerTypes.idl
492 * @tc.type: FUNC
493 */
494 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest025, TestSize.Level3)
495 {
496 printf("HdfPowerHdiTest025: start.");
497 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfState::AWAKE == 0);
498 printf("HdfPowerHdiTest025: end.");
499 }
500
501 /**
502 * @tc.name: HdfPowerHdiTest026
503 * @tc.desc: Judgment PowerHdfState enum value of the PowerTypes.idl
504 * @tc.type: FUNC
505 */
506 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest026, TestSize.Level3)
507 {
508 printf("HdfPowerHdiTest026: start.");
509 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfState::INACTIVE == 1);
510 printf("HdfPowerHdiTest026: end.");
511 }
512
513 /**
514 * @tc.name: HdfPowerHdiTest027
515 * @tc.desc: Judgment PowerHdfState enum value of the PowerTypes.idl
516 * @tc.type: FUNC
517 */
518 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest027, TestSize.Level3)
519 {
520 printf("HdfPowerHdiTest027: start.");
521 EXPECT_TRUE(OHOS::HDI::Power::V1_1::PowerHdfState::SLEEP == 2);
522 printf("HdfPowerHdiTest027: end.");
523 }
524
525 /**
526 * @tc.name: HdfPowerHdiTest028
527 * @tc.desc: Judgment BaseRunningLockType enum value of the RunningLockTypes.idl
528 * @tc.type: FUNC
529 */
530 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest028, TestSize.Level3)
531 {
532 printf("HdfPowerHdiTest028: start.");
533 EXPECT_TRUE(OHOS::HDI::Power::V1_1::BaseRunningLockType::RUNNINGLOCK_SCREEN == 0);
534 printf("HdfPowerHdiTest028: end.");
535 }
536
537 /**
538 * @tc.name: HdfPowerHdiTest029
539 * @tc.desc: Judgment BaseRunningLockType enum value of the RunningLockTypes.idl
540 * @tc.type: FUNC
541 */
542 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest029, TestSize.Level3)
543 {
544 printf("HdfPowerHdiTest029: start.");
545 EXPECT_TRUE(OHOS::HDI::Power::V1_1::BaseRunningLockType::RUNNINGLOCK_BACKGROUND == 1);
546 printf("HdfPowerHdiTest029: end.");
547 }
548
549 /**
550 * @tc.name: HdfPowerHdiTest030
551 * @tc.desc: Judgment BaseRunningLockType enum value of the RunningLockTypes.idl
552 * @tc.type: FUNC
553 */
554 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest030, TestSize.Level3)
555 {
556 printf("HdfPowerHdiTest030: start.");
557 EXPECT_TRUE(OHOS::HDI::Power::V1_1::BaseRunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL == 2);
558 printf("HdfPowerHdiTest030: end.");
559 }
560
561 /**
562 * @tc.name: HdfPowerHdiTest031
563 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
564 * @tc.type: FUNC
565 */
566 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest031, TestSize.Level3)
567 {
568 printf("HdfPowerHdiTest031: start.");
569 EXPECT_TRUE(OHOS::HDI::Power::V1_1::RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE == 3);
570 printf("HdfPowerHdiTest031: end.");
571 }
572
573 /**
574 * @tc.name: HdfPowerHdiTest032
575 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
576 * @tc.type: FUNC
577 */
578 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest032, TestSize.Level3)
579 {
580 printf("HdfPowerHdiTest032: start.");
581 EXPECT_TRUE(OHOS::HDI::Power::V1_1::RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION == 5);
582 printf("HdfPowerHdiTest032: end.");
583 }
584
585 /**
586 * @tc.name: HdfPowerHdiTest033
587 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
588 * @tc.type: FUNC
589 */
590 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest033, TestSize.Level3)
591 {
592 printf("HdfPowerHdiTest033: start.");
593 EXPECT_TRUE(OHOS::HDI::Power::V1_1::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO == 9);
594 printf("HdfPowerHdiTest033: end.");
595 }
596
597 /**
598 * @tc.name: HdfPowerHdiTest034
599 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
600 * @tc.type: FUNC
601 */
602 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest034, TestSize.Level3)
603 {
604 printf("HdfPowerHdiTest034: start.");
605 EXPECT_TRUE(OHOS::HDI::Power::V1_1::RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT == 17);
606 printf("HdfPowerHdiTest034: end.");
607 }
608
609 /**
610 * @tc.name: HdfPowerHdiTest035
611 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
612 * @tc.type: FUNC
613 */
614 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest035, TestSize.Level3)
615 {
616 printf("HdfPowerHdiTest035: start.");
617 EXPECT_TRUE(OHOS::HDI::Power::V1_1::RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION == 33);
618 printf("HdfPowerHdiTest035: end.");
619 }
620
621 /**
622 * @tc.name: HdfPowerHdiTest036
623 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
624 * @tc.type: FUNC
625 */
626 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest036, TestSize.Level3)
627 {
628 printf("HdfPowerHdiTest036: start.");
629 EXPECT_TRUE(OHOS::HDI::Power::V1_1::RunningLockType::RUNNINGLOCK_BACKGROUND_TASK == 65);
630 printf("HdfPowerHdiTest036: end.");
631 }
632
633 /**
634 * @tc.name: HdfPowerHdiTest037
635 * @tc.desc: Judgment RunningLockType enum value of the RunningLockTypes.idl
636 * @tc.type: FUNC
637 */
638 HWTEST_F(HdfPowerHdiTest, HdfPowerHdiTest037, TestSize.Level3)
639 {
640 printf("HdfPowerHdiTest037: start.");
641 EXPECT_TRUE(OHOS::HDI::Power::V1_1::RunningLockType::RUNNINGLOCK_BUTT == 66);
642 printf("HdfPowerHdiTest037: end.");
643 }
644 }
645