• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "power_mgr_client_test.h"
17 
18 #include <iostream>
19 
20 #include <datetime_ex.h>
21 #include <gtest/gtest.h>
22 #include <if_system_ability_manager.h>
23 #include <ipc_skeleton.h>
24 #include <string_ex.h>
25 
26 #include "display_power_mgr_client.h"
27 #include "running_lock_token_stub.h"
28 #include "power_common.h"
29 #include "power_mgr_client.h"
30 #include "power_mgr_service.h"
31 #include "power_state_machine.h"
32 
33 using namespace testing::ext;
34 using namespace OHOS::PowerMgr;
35 using namespace OHOS;
36 using namespace std;
37 
38 namespace {
39 /**
40  * @tc.name: PowerMgrClient001
41  * @tc.desc: test RefreshActivity
42  * @tc.type: FUNC
43  * @tc.require: issueI5MJZJ
44  */
45 HWTEST_F(PowerMgrClientTest, PowerMgrClient001, TestSize.Level2)
46 {
47     POWER_HILOGD(LABEL_TEST, "PowerMgrClient001::fun is start!");
48     auto& powerMgrClient = PowerMgrClient::GetInstance();
49 
50     // Wakeup Device before test
51     powerMgrClient.WakeupDevice();
52     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient001: Prepare Fail, Screen is OFF.";
53     powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
54     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
55     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient001: Prepare Fail, Screen is OFF.";
56     powerMgrClient.RefreshActivity();
57     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
58     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
59 
60     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient001: RefreshActivity Device Fail, Screen is OFF";
61     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
62     POWER_HILOGD(LABEL_TEST, "PowerMgrClient001::fun is end!");
63 }
64 
65 /**
66  * @tc.name: PowerMgrClient002
67  * @tc.desc: test RefreshActivity
68  * @tc.type: FUNC
69  * @tc.require: issueI5MJZJ
70  */
71 HWTEST_F(PowerMgrClientTest, PowerMgrClient002, TestSize.Level2)
72 {
73     POWER_HILOGD(LABEL_TEST, "PowerMgrClient002::fun is start!");
74     auto& powerMgrClient = PowerMgrClient::GetInstance();
75 
76     // Wakeup Device before test
77     powerMgrClient.WakeupDevice();
78     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient002: Prepare Fail, Screen is OFF.";
79     powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
80     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
81     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient002: Prepare Fail, Screen is OFF.";
82     powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_BUTTON);
83     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
84     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
85 
86     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient002: RefreshActivity Device Fail, Screen is OFF";
87     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
88     POWER_HILOGD(LABEL_TEST, "PowerMgrClient002::fun is end!");
89 }
90 
91 /**
92  * @tc.name: PowerMgrClient003
93  * @tc.desc: test RefreshActivity
94  * @tc.type: FUNC
95  * @tc.require: issueI5MJZJ
96  */
97 HWTEST_F(PowerMgrClientTest, PowerMgrClient003, TestSize.Level2)
98 {
99     POWER_HILOGD(LABEL_TEST, "PowerMgrClient003::fun is start!");
100     auto& powerMgrClient = PowerMgrClient::GetInstance();
101 
102     // Wakeup Device before test
103     powerMgrClient.WakeupDevice();
104     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient003: Prepare Fail, Screen is OFF.";
105     powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
106     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
107     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient003: Prepare Fail, Screen is OFF.";
108     powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_TOUCH);
109     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
110     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
111 
112     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient003: RefreshActivity Device Fail, Screen is OFF";
113     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
114     POWER_HILOGD(LABEL_TEST, "PowerMgrClient003::fun is end!");
115 }
116 
117 /**
118  * @tc.name: PowerMgrClient004
119  * @tc.desc: test RefreshActivity
120  * @tc.type: FUNC
121  * @tc.require: issueI5MJZJ
122  */
123 HWTEST_F(PowerMgrClientTest, PowerMgrClient004, TestSize.Level2)
124 {
125     POWER_HILOGD(LABEL_TEST, "PowerMgrClient004::fun is start!");
126     auto& powerMgrClient = PowerMgrClient::GetInstance();
127 
128     // Wakeup Device before test
129     powerMgrClient.WakeupDevice();
130     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient004: Prepare Fail, Screen is OFF.";
131     powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
132     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
133     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient004: Prepare Fail, Screen is OFF.";
134     powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY);
135     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
136     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
137 
138     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient004: RefreshActivity Device Fail, Screen is OFF";
139     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
140     POWER_HILOGD(LABEL_TEST, "PowerMgrClient004::fun is end!");
141 }
142 
143 /**
144  * @tc.name: PowerMgrClient005
145  * @tc.desc: test RefreshActivity
146  * @tc.type: FUNC
147  * @tc.require: issueI5MJZJ
148  */
149 HWTEST_F(PowerMgrClientTest, PowerMgrClient005, TestSize.Level2)
150 {
151     POWER_HILOGD(LABEL_TEST, "PowerMgrClient005::fun is start!");
152     auto& powerMgrClient = PowerMgrClient::GetInstance();
153 
154     // Wakeup Device before test
155     powerMgrClient.WakeupDevice();
156     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient005: Prepare Fail, Screen is OFF.";
157     powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
158     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
159     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient005: Prepare Fail, Screen is OFF.";
160     powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_ATTENTION);
161     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
162     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
163 
164     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient005: RefreshActivity Device Fail, Screen is OFF";
165     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
166     POWER_HILOGD(LABEL_TEST, "PowerMgrClient005::fun is end!");
167 }
168 
169 /**
170  * @tc.name: PowerMgrClient006
171  * @tc.desc: test RefreshActivity
172  * @tc.type: FUNC
173  * @tc.require: issueI5MJZJ
174  */
175 HWTEST_F(PowerMgrClientTest, PowerMgrClient006, TestSize.Level2)
176 {
177     POWER_HILOGD(LABEL_TEST, "PowerMgrClient006::fun is start!");
178     auto& powerMgrClient = PowerMgrClient::GetInstance();
179 
180     // Wakeup Device before test
181     powerMgrClient.WakeupDevice();
182     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient006: Prepare Fail, Screen is OFF.";
183     powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
184     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
185     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient006: Prepare Fail, Screen is OFF.";
186     powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE);
187     sleep(SCREEN_OFF_WAIT_TIME_S / 2);
188     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
189 
190     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient006: RefreshActivity Device Fail, Screen is OFF";
191     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
192     POWER_HILOGD(LABEL_TEST, "PowerMgrClient006::fun is end!");
193 }
194 
195 /**
196  * @tc.name: PowerMgrClient007
197  * @tc.desc: test RefreshActivity
198  * @tc.type: FUNC
199  * @tc.require: issueI5MJZJ
200  */
201 HWTEST_F(PowerMgrClientTest, PowerMgrClient007, TestSize.Level2)
202 {
203     POWER_HILOGD(LABEL_TEST, "PowerMgrClient007::fun is start!");
204     auto& powerMgrClient = PowerMgrClient::GetInstance();
205     UserActivityType abnormaltype = UserActivityType(9);
206 
207     // Wakeup Device before test
208     powerMgrClient.WakeupDevice();
209     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient007: Prepare Fail, Screen is OFF.";
210     powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
211     usleep(SCREEN_OFF_WAIT_TIME_S * TRANSFER_NS_TO_MS / 2);
212     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient007: Prepare Fail, Screen is OFF.";
213     powerMgrClient.RefreshActivity(abnormaltype);
214     usleep(SCREEN_OFF_WAIT_TIME_S * TRANSFER_NS_TO_MS / 2 + TRANSFER_NS_TO_MS);
215     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
216 
217     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient007: RefreshActivity Device Fail, Screen is OFF";
218     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
219     POWER_HILOGD(LABEL_TEST, "PowerMgrClient007::fun is end!");
220 }
221 
222 /**
223  * @tc.name: PowerMgrClient008
224  * @tc.desc: test DISPLAY_DIM
225  * @tc.type: FUNC
226  * @tc.require: issueI5MJZJ
227  */
228 HWTEST_F(PowerMgrClientTest, PowerMgrClient008, TestSize.Level2)
229 {
230     POWER_HILOGD(LABEL_TEST, "PowerMgrClient008::fun is start!");
231     int64_t time = SCREEN_OFF_WAIT_TIME_MS;
232     auto& powerMgrClient = PowerMgrClient::GetInstance();
233     auto& displayMgrClient = OHOS::DisplayPowerMgr::DisplayPowerMgrClient::GetInstance();
234 
235     powerMgrClient.OverrideScreenOffTime(time);
236     // Wakeup Device before test
237     powerMgrClient.WakeupDevice();
238     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient008: Prepare Fail, Screen is OFF.";
239     usleep(time * TRANSFER_MS_TO_S * DIM_RATE);
240     auto ret = displayMgrClient.GetDisplayState();
241     EXPECT_EQ(ret, DisplayPowerMgr::DisplayState::DISPLAY_DIM);
242 
243     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
244     POWER_HILOGD(LABEL_TEST, "PowerMgrClient008::fun is end!");
245 }
246 
247 /**
248  * @tc.name: PowerMgrClient009
249  * @tc.desc: test WakeupDevice
250  * @tc.type: FUNC
251  * @tc.require: issueI5MJZJ
252  */
253 HWTEST_F(PowerMgrClientTest, PowerMgrClient009, TestSize.Level0)
254 {
255     POWER_HILOGD(LABEL_TEST, "PowerMgrClient009::fun is start!");
256     int32_t wakeupReason = (static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + 1;
257     WakeupDeviceType abnormaltype = WakeupDeviceType(wakeupReason);
258     auto& powerMgrClient = PowerMgrClient::GetInstance();
259 
260     // Suspend Device before test
261     powerMgrClient.SuspendDevice();
262     sleep(SLEEP_WAIT_TIME_S);
263     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient009: Prepare Fail, Screen is On.";
264     powerMgrClient.WakeupDevice(abnormaltype);
265     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
266 
267     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient009: Wakeup Device Fail, Screen is Off";
268 
269     POWER_HILOGD(LABEL_TEST, "PowerMgrClient009::fun is end!");
270 }
271 
272 /**
273  * @tc.name: PowerMgrClient010
274  * @tc.desc: test Suspend Device
275  * @tc.type: FUNC
276  * @tc.require: issueI5MJZJ
277  */
278 HWTEST_F(PowerMgrClientTest, PowerMgrClient010, TestSize.Level0)
279 {
280     POWER_HILOGD(LABEL_TEST, "PowerMgrClient010::fun is start!");
281     auto& powerMgrClient = PowerMgrClient::GetInstance();
282     int32_t suspendReason = (static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_MAX)) + 1;
283     SuspendDeviceType abnormaltype = SuspendDeviceType(suspendReason);
284 
285     // Wakeup Device before test
286     powerMgrClient.WakeupDevice();
287     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient010: Prepare Fail, Screen is OFF.";
288     powerMgrClient.SuspendDevice(abnormaltype, false);
289     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
290 
291     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient010: Suspend Device Fail, Screen is On";
292     POWER_HILOGD(LABEL_TEST, "PowerMgrClient010::fun is end!");
293 }
294 
295 /**
296  * @tc.name: PowerMgrClient011
297  * @tc.desc: test  auto suspend
298  * @tc.type: FUNC
299  * @tc.require: issueI5MJZJ
300  */
301 HWTEST_F(PowerMgrClientTest, PowerMgrClient011, TestSize.Level2)
302 {
303     POWER_HILOGD(LABEL_TEST, "PowerMgrClient011::fun is start!");
304     int32_t time = SLEEP_WAIT_TIME_MS;
305     auto& powerMgrClient = PowerMgrClient::GetInstance();
306     auto& displayMgrClient = OHOS::DisplayPowerMgr::DisplayPowerMgrClient::GetInstance();
307 
308     powerMgrClient.OverrideScreenOffTime(time);
309     // Wakeup Device before test
310     powerMgrClient.WakeupDevice();
311     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient011: Prepare Fail, Screen is OFF.";
312     POWER_HILOGD(LABEL_TEST, "PowerMgrClient011::1!");
313     usleep(time * TRANSFER_MS_TO_S * DIM_RATE);
314     auto ret = displayMgrClient.GetDisplayState();
315     EXPECT_EQ(ret, DisplayPowerMgr::DisplayState::DISPLAY_DIM);
316     POWER_HILOGD(LABEL_TEST, "PowerMgrClient011::3!");
317     usleep(time * TRANSFER_MS_TO_S * DIM_RATE);
318     POWER_HILOGD(LABEL_TEST, "PowerMgrClient011::8!");
319     ret = displayMgrClient.GetDisplayState();
320     EXPECT_EQ(ret, DisplayPowerMgr::DisplayState::DISPLAY_OFF);
321 
322     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
323     POWER_HILOGD(LABEL_TEST, "PowerMgrClient011::fun is end!");
324 }
325 
326 /**
327  * @tc.name: PowerMgrClient012
328  * @tc.desc: test SCREEN_ON RunningLock
329  * @tc.type: FUNC
330  * @tc.require: issueI5MJZJ
331  */
332 HWTEST_F(PowerMgrClientTest, PowerMgrClient012, TestSize.Level2)
333 {
334     POWER_HILOGD(LABEL_TEST, "PowerMgrClient012:Start.");
335     int32_t time = SLEEP_WAIT_TIME_MS;
336     auto& powerMgrClient = PowerMgrClient::GetInstance();
337     auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN);
338     powerMgrClient.OverrideScreenOffTime(time);
339     runningLock->Lock();
340     EXPECT_EQ(runningLock->IsUsed(), true);
341     EXPECT_EQ(powerMgrClient.IsScreenOn(), true);
342     usleep(time * TRANSFER_MS_TO_S);
343     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
344     runningLock->UnLock();
345     EXPECT_EQ(runningLock->IsUsed(), false);
346     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
347     POWER_HILOGD(LABEL_TEST, "PowerMgrClient012:End.");
348 }
349 
350 /**
351  * @tc.name: PowerMgrClient013
352  * @tc.desc: test SCREEN_ON RunningLock
353  * @tc.type: FUNC
354  * @tc.require: issueI5MJZJ
355  */
356 HWTEST_F(PowerMgrClientTest, PowerMgrClient013, TestSize.Level2)
357 {
358     POWER_HILOGD(LABEL_TEST, "PowerMgrClient013:Start.");
359 
360     int32_t time = SLEEP_WAIT_TIME_MS;
361     auto& powerMgrClient = PowerMgrClient::GetInstance();
362     auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN);
363     powerMgrClient.OverrideScreenOffTime(time);
364 
365     runningLock->Lock();
366     EXPECT_EQ(runningLock->IsUsed(), true);
367 
368     runningLock->UnLock();
369     EXPECT_EQ(runningLock->IsUsed(), false);
370     usleep(time * TRANSFER_MS_TO_S * DOUBLE_TIMES);
371     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
372     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
373     POWER_HILOGD(LABEL_TEST, "PowerMgrClient013:End.");
374 }
375 
376 /**
377  * @tc.name: PowerMgrClient014
378  * @tc.desc: test SCREEN_ON RunningLock
379  * @tc.type: FUNC
380  * @tc.require: issueI5MJZJ
381  */
382 HWTEST_F(PowerMgrClientTest, PowerMgrClient014, TestSize.Level2)
383 {
384     POWER_HILOGD(LABEL_TEST, "PowerMgrClient014:Start.");
385 
386     int32_t time = SLEEP_WAIT_TIME_MS;
387     auto& powerMgrClient = PowerMgrClient::GetInstance();
388     auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN);
389     powerMgrClient.OverrideScreenOffTime(time);
390 
391     runningLock->Lock();
392     EXPECT_EQ(runningLock->IsUsed(), true);
393     EXPECT_EQ(powerMgrClient.IsScreenOn(), true);
394     usleep(time * TRANSFER_MS_TO_S * DOUBLE_TIMES);
395     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
396 
397     runningLock->UnLock();
398     EXPECT_EQ(runningLock->IsUsed(), false);
399     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
400     POWER_HILOGD(LABEL_TEST, "PowerMgrClient014:End.");
401 }
402 
403 /**
404  * @tc.name: PowerMgrClient015
405  * @tc.desc: test SCREEN_ON RunningLock
406  * @tc.type: FUNC
407  * @tc.require: issueI5MJZJ
408  */
409 HWTEST_F(PowerMgrClientTest, PowerMgrClient015, TestSize.Level2)
410 {
411     POWER_HILOGD(LABEL_TEST, "PowerMgrClient015:Start.");
412 
413     int32_t time = SLEEP_WAIT_TIME_MS;
414     auto& powerMgrClient = PowerMgrClient::GetInstance();
415     auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN);
416 
417     powerMgrClient.OverrideScreenOffTime(time);
418 
419     runningLock->Lock();
420     EXPECT_EQ(runningLock->IsUsed(), true);
421     EXPECT_EQ(powerMgrClient.IsScreenOn(), true);
422     powerMgrClient.SuspendDevice();
423     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
424 
425     runningLock->UnLock();
426     EXPECT_EQ(runningLock->IsUsed(), false);
427     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
428     POWER_HILOGD(LABEL_TEST, "PowerMgrClient015:End.");
429 }
430 
431 /**
432  * @tc.name: PowerMgrClient016
433  * @tc.desc: test SCREEN_ON RunningLock
434  * @tc.type: FUNC
435  * @tc.require: issueI5MJZJ
436  */
437 HWTEST_F(PowerMgrClientTest, PowerMgrClient016, TestSize.Level2)
438 {
439     POWER_HILOGD(LABEL_TEST, "PowerMgrClient016:Start.");
440 
441     int32_t time = SLEEP_WAIT_TIME_MS;
442     auto& powerMgrClient = PowerMgrClient::GetInstance();
443     auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN);
444 
445     powerMgrClient.OverrideScreenOffTime(time);
446 
447     powerMgrClient.SuspendDevice();
448     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
449     runningLock->Lock();
450     EXPECT_EQ(runningLock->IsUsed(), true);
451     EXPECT_EQ(powerMgrClient.IsScreenOn(), true);
452     usleep(time * TRANSFER_MS_TO_S);
453     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
454 
455     runningLock->UnLock();
456     EXPECT_EQ(runningLock->IsUsed(), false);
457     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
458     POWER_HILOGD(LABEL_TEST, "PowerMgrClient016:End.");
459 }
460 
461 /**
462  * @tc.name: PowerMgrClient017
463  * @tc.desc: test background RunningLock
464  * @tc.type: FUNC
465  * @tc.require: issueI5MJZJ
466  */
467 HWTEST_F(PowerMgrClientTest, PowerMgrClient017, TestSize.Level2)
468 {
469     POWER_HILOGD(LABEL_TEST, "PowerMgrClient017:Start.");
470 
471     int32_t time = SLEEP_WAIT_TIME_MS;
472     auto& powerMgrClient = PowerMgrClient::GetInstance();
473     auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_BACKGROUND);
474 
475     powerMgrClient.OverrideScreenOffTime(time);
476 
477     powerMgrClient.SuspendDevice();
478     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
479     runningLock->Lock();
480     EXPECT_EQ(runningLock->IsUsed(), true);
481     sleep(5);
482     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
483 
484     runningLock->UnLock();
485     EXPECT_EQ(runningLock->IsUsed(), false);
486     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
487     POWER_HILOGD(LABEL_TEST, "PowerMgrClient017:End.");
488 }
489 
490 /**
491  * @tc.name: PowerMgrClient018
492  * @tc.desc: test background RunningLock
493  * @tc.type: FUNC
494  * @tc.require: issueI5MJZJ
495  */
496 HWTEST_F(PowerMgrClientTest, PowerMgrClient018, TestSize.Level2)
497 {
498     POWER_HILOGD(LABEL_TEST, "PowerMgrClient018:Start.");
499 
500     auto& powerMgrClient = PowerMgrClient::GetInstance();
501     auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_BACKGROUND);
502 
503     runningLock->Lock();
504     EXPECT_EQ(runningLock->IsUsed(), true);
505     powerMgrClient.WakeupDevice();
506     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
507 
508     runningLock->UnLock();
509     EXPECT_EQ(runningLock->IsUsed(), false);
510     POWER_HILOGD(LABEL_TEST, "PowerMgrClient018:End.");
511 }
512 
513 /**
514  * @tc.name: PowerMgrClient019
515  * @tc.desc: test background RunningLock
516  * @tc.type: FUNC
517  * @tc.require: issueI5MJZJ
518  */
519 HWTEST_F(PowerMgrClientTest, PowerMgrClient019, TestSize.Level2)
520 {
521     POWER_HILOGD(LABEL_TEST, "PowerMgrClient019:Start.");
522 
523     int32_t time = SLEEP_WAIT_TIME_MS;
524     auto& powerMgrClient = PowerMgrClient::GetInstance();
525     auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_BACKGROUND);
526 
527     powerMgrClient.OverrideScreenOffTime(time);
528 
529     powerMgrClient.WakeupDevice();
530     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
531     runningLock->Lock();
532     EXPECT_EQ(runningLock->IsUsed(), true);
533     usleep(time * TRANSFER_MS_TO_S * DOUBLE_TIMES);
534     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
535     runningLock->UnLock();
536     EXPECT_EQ(runningLock->IsUsed(), false);
537     powerMgrClient.OverrideScreenOffTime(DEFAULT_SLEEP_TIME);
538     powerMgrClient.RestoreScreenOffTime();
539     POWER_HILOGD(LABEL_TEST, "PowerMgrClient019:End.");
540 }
541 
542 /**
543  * @tc.name: PowerMgrClient020
544  * @tc.desc: test SetDisplaySuspend
545  * @tc.type: FUNC
546  * @tc.require: issueI5MJZJ
547  */
548 HWTEST_F(PowerMgrClientTest, PowerMgrClient020, TestSize.Level2)
549 {
550     POWER_HILOGD(LABEL_TEST, "PowerMgrClient020::fun is start!");
551     auto& powerMgrClient = PowerMgrClient::GetInstance();
552 
553     powerMgrClient.SuspendDevice();
554     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
555     powerMgrClient.SetDisplaySuspend(true);
556 
557     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
558 
559     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
560     powerMgrClient.SetDisplaySuspend(false);
561     POWER_HILOGD(LABEL_TEST, "PowerMgrClient020::fun is end!");
562 }
563 
564 /**
565  * @tc.name: PowerMgrClient022
566  * @tc.desc: test Suspend Device in proxy
567  * @tc.type: FUNC
568  * @tc.require: issueI5MJZJ
569  */
570 HWTEST_F(PowerMgrClientTest, PowerMgrClient022, TestSize.Level0)
571 {
572     POWER_HILOGD(LABEL_TEST, "PowerMgrClient022::fun is start!");
573     auto& powerMgrClient = PowerMgrClient::GetInstance();
574 
575     // Wakeup Device before test
576     powerMgrClient.WakeupDevice();
577     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient022: Prepare Fail, Screen is OFF.";
578 
579     powerMgrClient.SuspendDevice();
580     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
581     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient022: Suspend Device Fail, Screen is On";
582 
583     POWER_HILOGD(LABEL_TEST, "PowerMgrClient022::fun is end!");
584 }
585 
586 /**
587  * @tc.name: PowerMgrClient023
588  * @tc.desc: test Suspend Device
589  * @tc.type: FUNC
590  * @tc.require: issueI5MJZJ
591  */
592 HWTEST_F(PowerMgrClientTest, PowerMgrClient023, TestSize.Level0)
593 {
594     POWER_HILOGD(LABEL_TEST, "PowerMgrClient023::fun is start!");
595     auto& powerMgrClient = PowerMgrClient::GetInstance();
596 
597     // Wakeup Device before test
598     powerMgrClient.WakeupDevice();
599     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient023: Prepare Fail, Screen is OFF.";
600 
601     powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false);
602     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
603     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient023: Suspend Device Fail, Screen is On";
604 
605     POWER_HILOGD(LABEL_TEST, "PowerMgrClient023::fun is end!");
606 }
607 
608 /**
609  * @tc.name: PowerMgrClient024
610  * @tc.desc: test Suspend Device
611  * @tc.type: FUNC
612  * @tc.require: issueI5MJZJ
613  */
614 HWTEST_F(PowerMgrClientTest, PowerMgrClient024, TestSize.Level0)
615 {
616     POWER_HILOGD(LABEL_TEST, "PowerMgrClient024::fun is start!");
617     auto& powerMgrClient = PowerMgrClient::GetInstance();
618 
619     // Wakeup Device before test
620     powerMgrClient.WakeupDevice();
621     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient024: Prepare Fail, Screen is OFF.";
622 
623     powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false);
624     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
625     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient024: Suspend Device Fail, Screen is On";
626 
627     POWER_HILOGD(LABEL_TEST, "PowerMgrClient024::fun is end!");
628 }
629 
630 /**
631  * @tc.name: PowerMgrClient025
632  * @tc.desc: test Suspend Device
633  * @tc.type: FUNC
634  * @tc.require: issueI5MJZJ
635  */
636 HWTEST_F(PowerMgrClientTest, PowerMgrClient025, TestSize.Level0)
637 {
638     POWER_HILOGD(LABEL_TEST, "PowerMgrClient025::fun is start!");
639     auto& powerMgrClient = PowerMgrClient::GetInstance();
640 
641     // Wakeup Device before test
642     powerMgrClient.WakeupDevice();
643     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient025: Prepare Fail, Screen is OFF.";
644 
645     powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false);
646     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
647     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient025: Suspend Device Fail, Screen is On";
648 
649     POWER_HILOGD(LABEL_TEST, "PowerMgrClient025::fun is end!");
650 }
651 
652 /**
653  * @tc.name: PowerMgrClient026
654  * @tc.desc: test Suspend Device
655  * @tc.type: FUNC
656  * @tc.require: issueI5MJZJ
657  */
658 HWTEST_F(PowerMgrClientTest, PowerMgrClient026, TestSize.Level0)
659 {
660     POWER_HILOGD(LABEL_TEST, "PowerMgrClient026::fun is start!");
661     auto& powerMgrClient = PowerMgrClient::GetInstance();
662 
663     // Wakeup Device before test
664     powerMgrClient.WakeupDevice();
665     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient026: Prepare Fail, Screen is OFF.";
666 
667     powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false);
668     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
669     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient026: Suspend Device Fail, Screen is On";
670 
671     POWER_HILOGD(LABEL_TEST, "PowerMgrClient026::fun is end!");
672 }
673 
674 /**
675  * @tc.name: PowerMgrClient027
676  * @tc.desc: test Suspend Device
677  * @tc.type: FUNC
678  * @tc.require: issueI5MJZJ
679  */
680 HWTEST_F(PowerMgrClientTest, PowerMgrClient027, TestSize.Level0)
681 {
682     POWER_HILOGD(LABEL_TEST, "PowerMgrClient027::fun is start!");
683     auto& powerMgrClient = PowerMgrClient::GetInstance();
684 
685     // Wakeup Device before test
686     powerMgrClient.WakeupDevice();
687     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient027: Prepare Fail, Screen is OFF.";
688 
689     powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI, false);
690     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
691     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient027: Suspend Device Fail, Screen is On";
692 
693     POWER_HILOGD(LABEL_TEST, "PowerMgrClient027::fun is end!");
694 }
695 
696 /**
697  * @tc.name: PowerMgrClient028
698  * @tc.desc: test Suspend Device
699  * @tc.type: FUNC
700  * @tc.require: issueI5MJZJ
701  */
702 HWTEST_F(PowerMgrClientTest, PowerMgrClient028, TestSize.Level0)
703 {
704     POWER_HILOGD(LABEL_TEST, "PowerMgrClient028::fun is start!");
705     auto& powerMgrClient = PowerMgrClient::GetInstance();
706 
707     // Wakeup Device before test
708     powerMgrClient.WakeupDevice();
709     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient028: Prepare Fail, Screen is OFF.";
710 
711     powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON, false);
712     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
713     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient028: Suspend Device Fail, Screen is On";
714 
715     POWER_HILOGD(LABEL_TEST, "PowerMgrClient028::fun is end!");
716 }
717 
718 /**
719  * @tc.name: PowerMgrClient029
720  * @tc.desc: test Suspend Device
721  * @tc.type: FUNC
722  * @tc.require: issueI5MJZJ
723  */
724 HWTEST_F(PowerMgrClientTest, PowerMgrClient029, TestSize.Level0)
725 {
726     POWER_HILOGD(LABEL_TEST, "PowerMgrClient029::fun is start!");
727     auto& powerMgrClient = PowerMgrClient::GetInstance();
728 
729     // Wakeup Device before test
730     powerMgrClient.WakeupDevice();
731     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient029: Prepare Fail, Screen is OFF.";
732 
733     powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY, false);
734     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
735     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient029: Suspend Device Fail, Screen is On";
736 
737     POWER_HILOGD(LABEL_TEST, "PowerMgrClient029::fun is end!");
738 }
739 
740 /**
741  * @tc.name: PowerMgrClient030
742  * @tc.desc: test Suspend Device
743  * @tc.type: FUNC
744  * @tc.require: issueI5MJZJ
745  */
746 HWTEST_F(PowerMgrClientTest, PowerMgrClient030, TestSize.Level0)
747 {
748     POWER_HILOGD(LABEL_TEST, "PowerMgrClient030::fun is start!");
749     auto& powerMgrClient = PowerMgrClient::GetInstance();
750 
751     // Wakeup Device before test
752     powerMgrClient.WakeupDevice();
753     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient030: Prepare Fail, Screen is OFF.";
754 
755     powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND, false);
756     EXPECT_EQ(powerMgrClient.GetState(), PowerState::INACTIVE);
757     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient030: Suspend Device Fail, Screen is On";
758 
759     POWER_HILOGD(LABEL_TEST, "PowerMgrClient030::fun is end!");
760 }
761 
762 /**
763  * @tc.name: PowerMgrClient031
764  * @tc.desc: test WakeupDevice(int64_t timeMs) in proxy
765  * @tc.type: FUNC
766  * @tc.require: issueI5MJZJ
767  */
768 HWTEST_F(PowerMgrClientTest, PowerMgrClient031, TestSize.Level0)
769 {
770     POWER_HILOGD(LABEL_TEST, "PowerMgrClient031::fun is start!");
771     auto& powerMgrClient = PowerMgrClient::GetInstance();
772 
773     // Suspend Device before test
774     powerMgrClient.SuspendDevice();
775     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient031: Prepare Fail, Screen is On.";
776 
777     powerMgrClient.WakeupDevice();
778     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
779     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient031: Wakeup Device Fail, Screen is Off";
780 
781     POWER_HILOGD(LABEL_TEST, "PowerMgrClient031::fun is end!");
782 }
783 
784 /**
785  * @tc.name: PowerMgrClient032
786  * @tc.desc: test WakeupDevice
787  * @tc.type: FUNC
788  * @tc.require: issueI5MJZJ
789  */
790 HWTEST_F(PowerMgrClientTest, PowerMgrClient032, TestSize.Level0)
791 {
792     POWER_HILOGD(LABEL_TEST, "PowerMgrClient032::fun is start!");
793     auto& powerMgrClient = PowerMgrClient::GetInstance();
794 
795     // Suspend Device before test
796     powerMgrClient.SuspendDevice();
797     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient032: Prepare Fail, Screen is On.";
798 
799     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN);
800     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
801     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient032: Wakeup Device Fail, Screen is Off";
802 
803     POWER_HILOGD(LABEL_TEST, "PowerMgrClient032::fun is end!");
804 }
805 
806 /**
807  * @tc.name: PowerMgrClient033
808  * @tc.desc: test WakeupDevice
809  * @tc.type: FUNC
810  * @tc.require: issueI5MJZJ
811  */
812 HWTEST_F(PowerMgrClientTest, PowerMgrClient033, TestSize.Level0)
813 {
814     POWER_HILOGD(LABEL_TEST, "PowerMgrClient033::fun is start!");
815     auto& powerMgrClient = PowerMgrClient::GetInstance();
816 
817     // Suspend Device before test
818     powerMgrClient.SuspendDevice();
819     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient033: Prepare Fail, Screen is On.";
820 
821     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON);
822     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
823     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient033: Wakeup Device Fail, Screen is Off";
824 
825     POWER_HILOGD(LABEL_TEST, "PowerMgrClient033::fun is end!");
826 }
827 
828 /**
829  * @tc.name: PowerMgrClient034
830  * @tc.desc: test WakeupDevice
831  * @tc.type: FUNC
832  * @tc.require: issueI5MJZJ
833  */
834 HWTEST_F(PowerMgrClientTest, PowerMgrClient034, TestSize.Level0)
835 {
836     POWER_HILOGD(LABEL_TEST, "PowerMgrClient034::fun is start!");
837     auto& powerMgrClient = PowerMgrClient::GetInstance();
838 
839     // Suspend Device before test
840     powerMgrClient.SuspendDevice();
841     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient034: Prepare Fail, Screen is On.";
842 
843     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN);
844     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
845     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient034: Wakeup Device Fail, Screen is Off";
846 
847     POWER_HILOGD(LABEL_TEST, "PowerMgrClient034::fun is end!");
848 }
849 
850 /**
851  * @tc.name: PowerMgrClient035
852  * @tc.desc: test WakeupDevice
853  * @tc.type: FUNC
854  * @tc.require: issueI5MJZJ
855  */
856 HWTEST_F(PowerMgrClientTest, PowerMgrClient035, TestSize.Level0)
857 {
858     POWER_HILOGD(LABEL_TEST, "PowerMgrClient035::fun is start!");
859     auto& powerMgrClient = PowerMgrClient::GetInstance();
860 
861     // Suspend Device before test
862     powerMgrClient.SuspendDevice();
863     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient035: Prepare Fail, Screen is On.";
864 
865     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_GESTURE);
866     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
867     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient035: Wakeup Device Fail, Screen is Off";
868 
869     POWER_HILOGD(LABEL_TEST, "PowerMgrClient035::fun is end!");
870 }
871 
872 /**
873  * @tc.name: PowerMgrClient036
874  * @tc.desc: test WakeupDevice
875  * @tc.type: FUNC
876  * @tc.require: issueI5MJZJ
877  */
878 HWTEST_F(PowerMgrClientTest, PowerMgrClient036, TestSize.Level0)
879 {
880     POWER_HILOGD(LABEL_TEST, "PowerMgrClient036::fun is start!");
881     auto& powerMgrClient = PowerMgrClient::GetInstance();
882 
883     // Suspend Device before test
884     powerMgrClient.SuspendDevice();
885     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient036: Prepare Fail, Screen is On.";
886 
887     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH);
888     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
889     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient036: Wakeup Device Fail, Screen is Off";
890 
891     POWER_HILOGD(LABEL_TEST, "PowerMgrClient036::fun is end!");
892 }
893 
894 /**
895  * @tc.name: PowerMgrClient037
896  * @tc.desc: test WakeupDevice
897  * @tc.type: FUNC
898  * @tc.require: issueI5MJZJ
899  */
900 HWTEST_F(PowerMgrClientTest, PowerMgrClient037, TestSize.Level0)
901 {
902     POWER_HILOGD(LABEL_TEST, "PowerMgrClient037::fun is start!");
903     auto& powerMgrClient = PowerMgrClient::GetInstance();
904 
905     // Suspend Device before test
906     powerMgrClient.SuspendDevice();
907     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient037: Prepare Fail, Screen is On.";
908 
909     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY);
910     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
911     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient037: Wakeup Device Fail, Screen is Off";
912 
913     POWER_HILOGD(LABEL_TEST, "PowerMgrClient037::fun is end!");
914 }
915 
916 /**
917  * @tc.name: PowerMgrClient038
918  * @tc.desc: test WakeupDevice
919  * @tc.type: FUNC
920  * @tc.require: issueI5MJZJ
921  */
922 HWTEST_F(PowerMgrClientTest, PowerMgrClient038, TestSize.Level0)
923 {
924     POWER_HILOGD(LABEL_TEST, "PowerMgrClient038::fun is start!");
925     auto& powerMgrClient = PowerMgrClient::GetInstance();
926 
927     // Suspend Device before test
928     powerMgrClient.SuspendDevice();
929     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient038: Prepare Fail, Screen is On.";
930 
931     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION);
932     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
933     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient038: Wakeup Device Fail, Screen is Off";
934 
935     POWER_HILOGD(LABEL_TEST, "PowerMgrClient038::fun is end!");
936 }
937 
938 /**
939  * @tc.name: PowerMgrClient039
940  * @tc.desc: test WakeupDevice
941  * @tc.type: FUNC
942  * @tc.require: issueI5MJZJ
943  */
944 HWTEST_F(PowerMgrClientTest, PowerMgrClient039, TestSize.Level0)
945 {
946     POWER_HILOGD(LABEL_TEST, "PowerMgrClient039::fun is start!");
947     auto& powerMgrClient = PowerMgrClient::GetInstance();
948 
949     // Suspend Device before test
950     powerMgrClient.SuspendDevice();
951     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient039: Prepare Fail, Screen is On.";
952 
953     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_HDMI);
954     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
955     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient039: Wakeup Device Fail, Screen is Off";
956 
957     POWER_HILOGD(LABEL_TEST, "PowerMgrClient039::fun is end!");
958 }
959 
960 /**
961  * @tc.name: PowerMgrClient040
962  * @tc.desc: test WakeupDevice
963  * @tc.type: FUNC
964  * @tc.require: issueI5MJZJ
965  */
966 HWTEST_F(PowerMgrClientTest, PowerMgrClient040, TestSize.Level0)
967 {
968     POWER_HILOGD(LABEL_TEST, "PowerMgrClient040::fun is start!");
969     auto& powerMgrClient = PowerMgrClient::GetInstance();
970 
971     // Suspend Device before test
972     powerMgrClient.SuspendDevice();
973     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient040: Prepare Fail, Screen is On.";
974 
975     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_LID);
976     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
977     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient040: Wakeup Device Fail, Screen is Off";
978 
979     POWER_HILOGD(LABEL_TEST, "PowerMgrClient040::fun is end!");
980 }
981 
982 /**
983  * @tc.name: PowerMgrClient041
984  * @tc.desc: test WakeupDevice
985  * @tc.type: FUNC
986  * @tc.require: issueI5MJZJ
987  */
988 HWTEST_F(PowerMgrClientTest, PowerMgrClient041, TestSize.Level0)
989 {
990     POWER_HILOGD(LABEL_TEST, "PowerMgrClient041::fun is start!");
991     auto& powerMgrClient = PowerMgrClient::GetInstance();
992 
993     // Suspend Device before test
994     powerMgrClient.SuspendDevice();
995     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient041: Prepare Fail, Screen is On.";
996 
997     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK);
998     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
999     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient041: Wakeup Device Fail, Screen is Off";
1000 
1001     POWER_HILOGD(LABEL_TEST, "PowerMgrClient041::fun is end!");
1002 }
1003 
1004 /**
1005  * @tc.name: PowerMgrClient042
1006  * @tc.desc: test WakeupDevice
1007  * @tc.type: FUNC
1008  * @tc.require: issueI5MJZJ
1009  */
1010 HWTEST_F(PowerMgrClientTest, PowerMgrClient042, TestSize.Level0)
1011 {
1012     POWER_HILOGD(LABEL_TEST, "PowerMgrClient042::fun is start!");
1013     auto& powerMgrClient = PowerMgrClient::GetInstance();
1014 
1015     // Suspend Device before test
1016     powerMgrClient.SuspendDevice();
1017     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient042: Prepare Fail, Screen is On.";
1018 
1019     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD);
1020     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
1021     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient042: Wakeup Device Fail, Screen is Off";
1022 
1023     POWER_HILOGD(LABEL_TEST, "PowerMgrClient042::fun is end!");
1024 }
1025 
1026 /**
1027  * @tc.name: PowerMgrClient043
1028  * @tc.desc: test WakeupDevice
1029  * @tc.type: FUNC
1030  * @tc.require: issueI5MJZJ
1031  */
1032 HWTEST_F(PowerMgrClientTest, PowerMgrClient043, TestSize.Level0)
1033 {
1034     POWER_HILOGD(LABEL_TEST, "PowerMgrClient043::fun is start!");
1035     auto& powerMgrClient = PowerMgrClient::GetInstance();
1036 
1037     // Suspend Device before test
1038     powerMgrClient.SuspendDevice();
1039     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient043: Prepare Fail, Screen is On.";
1040 
1041     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_MOUSE);
1042     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
1043     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient043: Wakeup Device Fail, Screen is Off";
1044 
1045     POWER_HILOGD(LABEL_TEST, "PowerMgrClient043::fun is end!");
1046 }
1047 
1048 /**
1049  * @tc.name: PowerMgrClient021
1050  * @tc.desc: test IsRunningLockTypeSupported
1051  * @tc.type: FUNC
1052  * @tc.require: issueI5MJZJ
1053  */
1054 HWTEST_F(PowerMgrClientTest, PowerMgrClient021, TestSize.Level2)
1055 {
1056     POWER_HILOGD(LABEL_TEST, "PowerMgrClient021:Start.");
1057 
1058     auto& powerMgrClient = PowerMgrClient::GetInstance();
1059 
1060     auto type = static_cast<uint32_t>(RunningLockType::RUNNINGLOCK_BUTT);
1061     auto ret = powerMgrClient.IsRunningLockTypeSupported(type);
1062     EXPECT_EQ(ret, false);
1063     type = static_cast<uint32_t>(RunningLockType::RUNNINGLOCK_SCREEN);
1064     ret = powerMgrClient.IsRunningLockTypeSupported(type);
1065     EXPECT_EQ(ret, true);
1066     type = static_cast<uint32_t>(RunningLockType::RUNNINGLOCK_BACKGROUND);
1067     ret = powerMgrClient.IsRunningLockTypeSupported(type);
1068     EXPECT_EQ(ret, true);
1069     type = static_cast<uint32_t>(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
1070     ret = powerMgrClient.IsRunningLockTypeSupported(type);
1071     EXPECT_EQ(ret, true);
1072     powerMgrClient.WakeupDevice();
1073     EXPECT_EQ(powerMgrClient.IsScreenOn(), true);
1074     powerMgrClient.SuspendDevice();
1075     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
1076 
1077     POWER_HILOGD(LABEL_TEST, "PowerMgrClient021:End.");
1078 }
1079 
1080 /**
1081  * @tc.name: PowerMgrClient023
1082  * @tc.desc: Test GetError
1083  * @tc.type: FUNC
1084  * @tc.require: issue I63PN9
1085  */
1086 HWTEST_F(PowerMgrClientTest, PowerMgrClient044, TestSize.Level2)
1087 {
1088     POWER_HILOGD(LABEL_TEST, "fun is start");
1089     PowerErrors error = PowerMgrClient::GetInstance().GetError();
1090     POWER_HILOGD(LABEL_TEST, "get error %{public}d", static_cast<int32_t>(error));
1091     POWER_HILOGD(error == PowerErrors::ERR_OK);
1092 }
1093 }