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