1 /*
2 * Copyright (c) 2021-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 "power_mgr_mock_test.h"
17
18 using namespace testing::ext;
19 using namespace OHOS::PowerMgr;
20 using namespace OHOS;
21 using namespace std;
22 using ::testing::_;
23
24 static sptr<PowerMgrService> service;
25 static MockStateAction* g_powerState;
26 static MockStateAction* g_stateAction;
27 static MockPowerAction* g_powerAction;
28 static MockLockAction* g_lockAction;
29
ResetMockAction()30 static void ResetMockAction()
31 {
32 POWER_HILOGD(LABEL_TEST, "ResetMockAction:Start.");
33 g_stateAction = new MockStateAction();
34 g_powerAction = new MockPowerAction();
35 g_lockAction = new MockLockAction();
36 service->EnableMock(g_powerState, g_stateAction, g_powerAction, g_lockAction);
37 }
38
SetUpTestCase(void)39 void PowerMgrMockTest::SetUpTestCase(void)
40 {
41 // create singleton service object at the beginning
42 service = DelayedSpSingleton<PowerMgrService>::GetInstance();
43 service->OnStart();
44 ResetMockAction();
45 }
46
TearDownTestCase(void)47 void PowerMgrMockTest::TearDownTestCase(void)
48 {
49 service->OnStop();
50 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
51 delete g_stateAction;
52 delete g_powerState;
53 delete g_powerAction;
54 delete g_lockAction;
55 }
56
SetUp(void)57 void PowerMgrMockTest::SetUp(void)
58 {
59 }
60
TearDown(void)61 void PowerMgrMockTest::TearDown(void)
62 {
63 }
64
65 namespace {
66 /**
67 * @tc.name: PowerMgrUnittest001
68 * @tc.desc: test RebootDevice by mock
69 * @tc.type: FUNC
70 */
71 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest001, TestSize.Level2)
72 {
73 sleep(NEXT_WAIT_TIME_S);
74 GTEST_LOG_(INFO) << "PowerMgrUnittest001: start.";
75 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest001:Start.");
76
77 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
78 if (pms == nullptr) {
79 GTEST_LOG_(INFO) << "PowerMgrUnittest001: Failed to get PowerMgrService";
80 }
81 if (false) {
82 EXPECT_CALL(*g_powerAction, Reboot(std::string("test"))).Times(1);
83 pms->RebootDevice(std::string("test"));
84 }
85
86 sleep(ASYNC_WAIT_TIME_S);
87
88 ResetMockAction();
89 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest001:End.");
90 GTEST_LOG_(INFO) << "PowerMgrUnittest001: end.";
91 }
92
93 /**
94 * @tc.name: PowerMgrUnittest002
95 * @tc.desc: test ShutDownDevice by mock
96 * @tc.type: FUNC
97 */
98 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest002, TestSize.Level2)
99 {
100 sleep(NEXT_WAIT_TIME_S);
101 GTEST_LOG_(INFO) << "PowerMgrUnittest002: start.";
102 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest002:Start.");
103
104 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
105 if (pms == nullptr) {
106 GTEST_LOG_(INFO) << "PowerMgrUnittest002: Failed to get PowerMgrService";
107 }
108
109 if (false) {
110 EXPECT_CALL(*g_powerAction, Shutdown(std::string("test"))).Times(1);
111 pms->ShutDownDevice(std::string("test"));
112 }
113 sleep(ASYNC_WAIT_TIME_S);
114
115 ResetMockAction();
116 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest002:End.");
117 GTEST_LOG_(INFO) << "PowerMgrUnittest002: end.";
118 }
119
120
121 /**
122 * @tc.name: PowerMgrUnittest003
123 * @tc.desc: test SuspendDevice by mock
124 * @tc.type: FUNC
125 */
126 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest003, TestSize.Level2)
127 {
128 sleep(NEXT_WAIT_TIME_S);
129 GTEST_LOG_(INFO) << "PowerMgrUnittest003: start.";
130
131 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest003:Start.");
132 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
133 if (pms == nullptr) {
134 GTEST_LOG_(INFO) << "PowerMgrUnittest003: Failed to get PowerMgrService";
135 }
136
137 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest003:Start mock.");
138 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
139 .Times(1)
140 .WillOnce(::testing::Return(ActionResult::SUCCESS));
141 EXPECT_CALL(*g_stateAction,
142 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false));
143 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest003:Start suspend.");
144 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
145
146 ResetMockAction();
147 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest003:end.");
148 GTEST_LOG_(INFO) << "PowerMgrUnittest003: end.";
149 }
150
151 /**
152 * @tc.name: PowerMgrUnittest004
153 * @tc.desc: test SuspendDevice by mock
154 * @tc.type: FUNC
155 */
156 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest004, TestSize.Level2)
157 {
158 sleep(NEXT_WAIT_TIME_S);
159 GTEST_LOG_(INFO) << "PowerMgrUnittest004: start.";
160 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest004:Start.");
161
162 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
163 if (pms == nullptr) {
164 GTEST_LOG_(INFO) << "PowerMgrUnittest004: Failed to get PowerMgrService";
165 }
166
167 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
168 .Times(1)
169 .WillOnce(::testing::Return(ActionResult::SUCCESS));
170 EXPECT_CALL(*g_stateAction,
171 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false));
172 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false);
173
174 ResetMockAction();
175 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest004:End .");
176 GTEST_LOG_(INFO) << "PowerMgrUnittest004: end.";
177 }
178
179 /**
180 * @tc.name: PowerMgrUnittest005
181 * @tc.desc: test SuspendDevice by mock
182 * @tc.type: FUNC
183 */
184 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest005, TestSize.Level2)
185 {
186 sleep(NEXT_WAIT_TIME_S);
187 GTEST_LOG_(INFO) << "PowerMgrUnittest005: start.";
188 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest005:Start.");
189
190 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
191 if (pms == nullptr) {
192 GTEST_LOG_(INFO) << "PowerMgrUnittest005: Failed to get PowerMgrService";
193 }
194
195 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
196 .Times(1)
197 .WillOnce(::testing::Return(ActionResult::SUCCESS));
198 EXPECT_CALL(*g_stateAction,
199 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false));
200 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false);
201
202 ResetMockAction();
203 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest005:End");
204 GTEST_LOG_(INFO) << "PowerMgrUnittest005: end.";
205 }
206
207 /**
208 * @tc.name: PowerMgrUnittest006
209 * @tc.desc: test SuspendDevice by mock
210 * @tc.type: FUNC
211 */
212 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest006, TestSize.Level2)
213 {
214 sleep(NEXT_WAIT_TIME_S);
215 GTEST_LOG_(INFO) << "PowerMgrUnittest006: start.";
216 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest006:Start.");
217
218 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
219 if (pms == nullptr) {
220 GTEST_LOG_(INFO) << "PowerMgrUnittest006: Failed to get PowerMgrService";
221 }
222
223 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
224 .Times(1)
225 .WillOnce(::testing::Return(ActionResult::SUCCESS));
226 EXPECT_CALL(*g_stateAction,
227 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false));
228 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false);
229
230 ResetMockAction();
231 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest006:End.");
232 GTEST_LOG_(INFO) << "PowerMgrUnittest006: end.";
233 }
234
235 /**
236 * @tc.name: PowerMgrUnittest007
237 * @tc.desc: test SuspendDevice by mock
238 * @tc.type: FUNC
239 */
240 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest007, TestSize.Level2)
241 {
242 sleep(NEXT_WAIT_TIME_S);
243 GTEST_LOG_(INFO) << "PowerMgrUnittest007: start.";
244 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest007:Start.");
245
246 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
247 if (pms == nullptr) {
248 GTEST_LOG_(INFO) << "PowerMgrUnittest007: Failed to get PowerMgrService";
249 }
250
251 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
252 .Times(1)
253 .WillOnce(::testing::Return(ActionResult::SUCCESS));
254 EXPECT_CALL(*g_stateAction,
255 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false));
256 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false);
257
258 ResetMockAction();
259 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest007:End.");
260 GTEST_LOG_(INFO) << "PowerMgrUnittest007: end.";
261 }
262
263 /**
264 * @tc.name: PowerMgrUnittest008
265 * @tc.desc: test SuspendDevice by mock
266 * @tc.type: FUNC
267 */
268 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest008, TestSize.Level2)
269 {
270 sleep(NEXT_WAIT_TIME_S);
271 GTEST_LOG_(INFO) << "PowerMgrUnittest008: start.";
272 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest008:Start.");
273
274 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
275 if (pms == nullptr) {
276 GTEST_LOG_(INFO) << "PowerMgrUnittest008: Failed to get PowerMgrService";
277 }
278
279 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
280 .Times(1)
281 .WillOnce(::testing::Return(ActionResult::SUCCESS));
282 EXPECT_CALL(*g_stateAction,
283 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI, false));
284 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI, false);
285
286 ResetMockAction();
287 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest008:End.");
288 GTEST_LOG_(INFO) << "PowerMgrUnittest008: end.";
289 }
290
291 /**
292 * @tc.name: PowerMgrUnittest009
293 * @tc.desc: test SuspendDevice by mock
294 * @tc.type: FUNC
295 */
296 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest009, TestSize.Level2)
297 {
298 sleep(NEXT_WAIT_TIME_S);
299 GTEST_LOG_(INFO) << "PowerMgrUnittest009: start.";
300 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest009:Start.");
301
302 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
303 if (pms == nullptr) {
304 GTEST_LOG_(INFO) << "PowerMgrUnittest009: Failed to get PowerMgrService";
305 }
306
307 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
308 .Times(1)
309 .WillOnce(::testing::Return(ActionResult::SUCCESS));
310 EXPECT_CALL(*g_stateAction,
311 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON, false));
312 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON, false);
313
314 ResetMockAction();
315 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest009:End.");
316 GTEST_LOG_(INFO) << "PowerMgrUnittest009: end.";
317 }
318
319 /**
320 * @tc.name: PowerMgrUnittest010
321 * @tc.desc: test SuspendDevice by mock
322 * @tc.type: FUNC
323 */
324 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest010, TestSize.Level2)
325 {
326 sleep(NEXT_WAIT_TIME_S);
327 GTEST_LOG_(INFO) << "PowerMgrUnittest010: start.";
328 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest010:Start.");
329
330 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
331 if (pms == nullptr) {
332 GTEST_LOG_(INFO) << "PowerMgrUnittest010: Failed to get PowerMgrService";
333 }
334
335 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
336 .Times(1)
337 .WillOnce(::testing::Return(ActionResult::SUCCESS));
338 EXPECT_CALL(*g_stateAction,
339 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY, false));
340 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY, false);
341
342 ResetMockAction();
343 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest010:End.");
344 GTEST_LOG_(INFO) << "PowerMgrUnittest010: end.";
345 }
346
347 /**
348 * @tc.name: PowerMgrUnittest011
349 * @tc.desc: test SuspendDevice by mock
350 * @tc.type: FUNC
351 */
352 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest011, TestSize.Level2)
353 {
354 sleep(NEXT_WAIT_TIME_S);
355 GTEST_LOG_(INFO) << "PowerMgrUnittest011: start.";
356 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest011:Start.");
357
358 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
359 if (pms == nullptr) {
360 GTEST_LOG_(INFO) << "PowerMgrUnittest011: Failed to get PowerMgrService";
361 }
362
363 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
364 .Times(1)
365 .WillOnce(::testing::Return(ActionResult::SUCCESS));
366 EXPECT_CALL(*g_stateAction,
367 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND, false));
368 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND, false);
369
370 ResetMockAction();
371 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest011:End.");
372 GTEST_LOG_(INFO) << "PowerMgrUnittest011: end.";
373 }
374
375 /**
376 * @tc.name: PowerMgrUnittest012
377 * @tc.desc: test WakeupDevice by mock
378 * @tc.type: FUNC
379 */
380 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest012, TestSize.Level2)
381 {
382 sleep(NEXT_WAIT_TIME_S);
383 GTEST_LOG_(INFO) << "PowerMgrUnittest012: start.";
384 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest012:Start.");
385
386 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
387 if (pms == nullptr) {
388 GTEST_LOG_(INFO) << "PowerMgrUnittest012: Failed to get PowerMgrService";
389 }
390
391 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
392 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
393 .Times(1)
394 .WillOnce(::testing::Return(ActionResult::SUCCESS));
395 EXPECT_CALL(*g_stateAction,
396 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN,
397 std::string("test"), _)).Times(1);
398 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
399
400 ResetMockAction();
401 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest012:End.");
402 GTEST_LOG_(INFO) << "PowerMgrUnittest012: end.";
403 }
404
405 /**
406 * @tc.name: PowerMgrUnittest013
407 * @tc.desc: test WakeupDevice by mock
408 * @tc.type: FUNC
409 */
410 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest013, TestSize.Level2)
411 {
412 sleep(NEXT_WAIT_TIME_S);
413 GTEST_LOG_(INFO) << "PowerMgrUnittest013: start.";
414 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest013:Start.");
415
416 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
417 if (pms == nullptr) {
418 GTEST_LOG_(INFO) << "PowerMgrUnittest013: Failed to get PowerMgrService";
419 }
420
421 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
422 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
423 .Times(1)
424 .WillOnce(::testing::Return(ActionResult::SUCCESS));
425 EXPECT_CALL(*g_stateAction,
426 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON,
427 std::string("test"), _)).Times(1);
428 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("test"));
429
430 ResetMockAction();
431 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest013:End.");
432 GTEST_LOG_(INFO) << "PowerMgrUnittest013: end.";
433 }
434
435 /**
436 * @tc.name: PowerMgrUnittest014
437 * @tc.desc: test WakeupDevice by mock
438 * @tc.type: FUNC
439 */
440 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest014, TestSize.Level2)
441 {
442 sleep(NEXT_WAIT_TIME_S);
443 GTEST_LOG_(INFO) << "PowerMgrUnittest014: start.";
444 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest014:Start.");
445
446 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
447 if (pms == nullptr) {
448 GTEST_LOG_(INFO) << "PowerMgrUnittest014: Failed to get PowerMgrService";
449 }
450
451 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
452 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
453 .Times(1)
454 .WillOnce(::testing::Return(ActionResult::SUCCESS));
455 EXPECT_CALL(*g_stateAction,
456 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION,
457 std::string("test"), _)).Times(1);
458 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, std::string("test"));
459
460 ResetMockAction();
461 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest014:End.");
462 GTEST_LOG_(INFO) << "PowerMgrUnittest014: end.";
463 }
464
465 /**
466 * @tc.name: PowerMgrUnittest015
467 * @tc.desc: test WakeupDevice by mock
468 * @tc.type: FUNC
469 */
470 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest015, TestSize.Level2)
471 {
472 sleep(NEXT_WAIT_TIME_S);
473 GTEST_LOG_(INFO) << "PowerMgrUnittest015: start.";
474 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest015:Start.");
475
476 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
477 if (pms == nullptr) {
478 GTEST_LOG_(INFO) << "PowerMgrUnittest015: Failed to get PowerMgrService";
479 }
480
481 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
482 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
483 .Times(1)
484 .WillOnce(::testing::Return(ActionResult::SUCCESS));
485 EXPECT_CALL(*g_stateAction,
486 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN,
487 std::string("test"), _)).Times(1);
488 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN, std::string("test"));
489
490 ResetMockAction();
491 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest015:End.");
492 GTEST_LOG_(INFO) << "PowerMgrUnittest015: end.";
493 }
494
495 /**
496 * @tc.name: PowerMgrUnittest016
497 * @tc.desc: test WakeupDevice by mock
498 * @tc.type: FUNC
499 */
500 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest016, TestSize.Level2)
501 {
502 sleep(NEXT_WAIT_TIME_S);
503 GTEST_LOG_(INFO) << "PowerMgrUnittest016: start.";
504 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest016:Start.");
505
506 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
507 if (pms == nullptr) {
508 GTEST_LOG_(INFO) << "PowerMgrUnittest016: Failed to get PowerMgrService";
509 }
510
511 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
512 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
513 .Times(1)
514 .WillOnce(::testing::Return(ActionResult::SUCCESS));
515 EXPECT_CALL(*g_stateAction,
516 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE,
517 std::string("test"), _)).Times(1);
518 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE, std::string("test"));
519
520 ResetMockAction();
521 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest016:End.");
522 GTEST_LOG_(INFO) << "PowerMgrUnittest016: end.";
523 }
524
525 /**
526 * @tc.name: PowerMgrUnittest017
527 * @tc.desc: test WakeupDevice by mock
528 * @tc.type: FUNC
529 */
530 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest017, TestSize.Level2)
531 {
532 sleep(NEXT_WAIT_TIME_S);
533 GTEST_LOG_(INFO) << "PowerMgrUnittest017: start.";
534 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest017:Start.");
535
536 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
537 if (pms == nullptr) {
538 GTEST_LOG_(INFO) << "PowerMgrUnittest017: Failed to get PowerMgrService";
539 }
540
541 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
542 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
543 .Times(1)
544 .WillOnce(::testing::Return(ActionResult::SUCCESS));
545 EXPECT_CALL(*g_stateAction,
546 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH,
547 std::string("test"), _)).Times(1);
548 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH, std::string("test"));
549
550 ResetMockAction();
551 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest017:End.");
552 GTEST_LOG_(INFO) << "PowerMgrUnittest017: end.";
553 }
554
555 /**
556 * @tc.name: PowerMgrUnittest018
557 * @tc.desc: test WakeupDevice by mock
558 * @tc.type: FUNC
559 */
560 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest018, TestSize.Level2)
561 {
562 sleep(NEXT_WAIT_TIME_S);
563 GTEST_LOG_(INFO) << "PowerMgrUnittest018: start.";
564 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest018:Start.");
565
566 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
567 if (pms == nullptr) {
568 GTEST_LOG_(INFO) << "PowerMgrUnittest018: Failed to get PowerMgrService";
569 }
570
571 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
572 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
573 .Times(1)
574 .WillOnce(::testing::Return(ActionResult::SUCCESS));
575 EXPECT_CALL(*g_stateAction,
576 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY,
577 std::string("test"), _)).Times(1);
578 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY, std::string("test"));
579
580 ResetMockAction();
581 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest018:End.");
582 GTEST_LOG_(INFO) << "PowerMgrUnittest018: end.";
583 }
584
585 /**
586 * @tc.name: PowerMgrUnittest019
587 * @tc.desc: test WakeupDevice by mock
588 * @tc.type: FUNC
589 */
590 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest019, TestSize.Level2)
591 {
592 sleep(NEXT_WAIT_TIME_S);
593 GTEST_LOG_(INFO) << "PowerMgrUnittest019: start.";
594 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest019:Start.");
595
596 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
597 if (pms == nullptr) {
598 GTEST_LOG_(INFO) << "PowerMgrUnittest019: Failed to get PowerMgrService";
599 }
600
601 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
602 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
603 .Times(1)
604 .WillOnce(::testing::Return(ActionResult::SUCCESS));
605 EXPECT_CALL(*g_stateAction,
606 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION,
607 std::string("test"), _)).Times(1);
608 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION, std::string("test"));
609
610 ResetMockAction();
611 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest019:End.");
612 GTEST_LOG_(INFO) << "PowerMgrUnittest019: end.";
613 }
614
615 /**
616 * @tc.name: PowerMgrUnittest020
617 * @tc.desc: test WakeupDevice by mock
618 * @tc.type: FUNC
619 */
620 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest020, TestSize.Level2)
621 {
622 sleep(NEXT_WAIT_TIME_S);
623 GTEST_LOG_(INFO) << "PowerMgrUnittest020: start.";
624 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest020:Start.");
625
626 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
627 if (pms == nullptr) {
628 GTEST_LOG_(INFO) << "PowerMgrUnittest020: Failed to get PowerMgrService";
629 }
630
631 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
632 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
633 .Times(1)
634 .WillOnce(::testing::Return(ActionResult::SUCCESS));
635 EXPECT_CALL(*g_stateAction,
636 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI,
637 std::string("test"), _)).Times(1);
638 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI, std::string("test"));
639
640 ResetMockAction();
641 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest020:End.");
642 GTEST_LOG_(INFO) << "PowerMgrUnittest020: end.";
643 }
644
645 /**
646 * @tc.name: PowerMgrUnittest021
647 * @tc.desc: test WakeupDevice by mock
648 * @tc.type: FUNC
649 */
650 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest021, TestSize.Level2)
651 {
652 sleep(NEXT_WAIT_TIME_S);
653 GTEST_LOG_(INFO) << "PowerMgrUnittest021: start.";
654 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest021:Start.");
655
656 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
657 if (pms == nullptr) {
658 GTEST_LOG_(INFO) << "PowerMgrUnittest021: Failed to get PowerMgrService";
659 }
660
661 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
662 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
663 .Times(1)
664 .WillOnce(::testing::Return(ActionResult::SUCCESS));
665 EXPECT_CALL(*g_stateAction,
666 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_LID,
667 std::string("test"), _)).Times(1);
668 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID, std::string("test"));
669
670 ResetMockAction();
671 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest021:End.");
672 GTEST_LOG_(INFO) << "PowerMgrUnittest021: end.";
673 }
674
675 /**
676 * @tc.name: PowerMgrUnittest022
677 * @tc.desc: test SuspendDevice and auto sleep by mock
678 * @tc.type: FUNC
679 */
680 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest022, TestSize.Level2)
681 {
682 sleep(NEXT_WAIT_TIME_S);
683 GTEST_LOG_(INFO) << "PowerMgrUnittest022: start.";
684 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest022:Start.");
685
686 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
687 if (pms == nullptr) {
688 GTEST_LOG_(INFO) << "PowerMgrUnittest022: Failed to get PowerMgrService";
689 }
690
691 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
692 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
693 .Times(::testing::AtLeast(1))
694 .WillOnce(::testing::Return(ActionResult::SUCCESS));
695 EXPECT_CALL(*g_stateAction,
696 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false));
697 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
698 .Times(1)
699 .WillOnce(::testing::Return(ActionResult::SUCCESS));
700 ON_CALL(*g_stateAction, GetDisplayState())
701 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
702 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
703 sleep(SLEEP_WAIT_TIME_S + 1);
704
705 ResetMockAction();
706 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest022:End.");
707 GTEST_LOG_(INFO) << "PowerMgrUnittest022: end.";
708 }
709
710 /**
711 * @tc.name: PowerMgrUnittest023
712 * @tc.desc: test WakeupDevice and auto suspend and sleep by mock
713 * @tc.type: FUNC
714 */
715 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest023, TestSize.Level2)
716 {
717 sleep(NEXT_WAIT_TIME_S);
718 GTEST_LOG_(INFO) << "PowerMgrUnittest023: start.";
719 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest023:Start.");
720
721 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
722 if (pms == nullptr) {
723 GTEST_LOG_(INFO) << "PowerMgrUnittest023: Failed to get PowerMgrService";
724 }
725
726 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
727 .Times(1)
728 .WillOnce(::testing::Return(ActionResult::SUCCESS));
729 ON_CALL(*g_stateAction, GetDisplayState())
730 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
731 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID, std::string("test"));
732 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
733 ON_CALL(*g_stateAction, GetDisplayState())
734 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
735 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
736 ON_CALL(*g_stateAction, GetDisplayState())
737 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
738 sleep(SLEEP_WAIT_TIME_S + 1);
739
740 ResetMockAction();
741 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest023:End.");
742 GTEST_LOG_(INFO) << "PowerMgrUnittest023: end.";
743 }
744
745 /**
746 * @tc.name: PowerMgrUnittest024
747 * @tc.desc: test RefreshActivity by mock
748 * @tc.type: FUNC
749 */
750 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest024, TestSize.Level2)
751 {
752 sleep(NEXT_WAIT_TIME_S);
753 GTEST_LOG_(INFO) << "PowerMgrUnittest024: start.";
754 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest024:Start.");
755
756 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
757 if (pms == nullptr) {
758 GTEST_LOG_(INFO) << "PowerMgrUnittest024: Failed to get PowerMgrService";
759 }
760
761 EXPECT_CALL(*g_stateAction, GetDisplayState())
762 .Times(::testing::AtLeast(1))
763 .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM));
764 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
765 .Times(1)
766 .WillOnce(::testing::Return(ActionResult::SUCCESS));
767 EXPECT_CALL(*g_stateAction,
768 RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, _)).Times(1);
769 pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, true);
770
771 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1);
772 ResetMockAction();
773 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest024:End.");
774 GTEST_LOG_(INFO) << "PowerMgrUnittest024: end.";
775 }
776
777 /**
778 * @tc.name: PowerMgrUnittest025
779 * @tc.desc: test IsScreenOn by mock
780 * @tc.type: FUNC
781 */
782 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest025, TestSize.Level2)
783 {
784 sleep(NEXT_WAIT_TIME_S);
785 GTEST_LOG_(INFO) << "PowerMgrUnittest025: start.";
786 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest025:Start.");
787
788 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
789 if (pms == nullptr) {
790 GTEST_LOG_(INFO) << "PowerMgrUnittest025: Failed to get PowerMgrService";
791 }
792
793 EXPECT_CALL(*g_stateAction, GetDisplayState())
794 .Times(::testing::AtLeast(1))
795 .WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
796 EXPECT_EQ(pms->IsScreenOn(), true);
797
798 ResetMockAction();
799 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest025:End.");
800 GTEST_LOG_(INFO) << "PowerMgrUnittest025: end.";
801 }
802
803 /**
804 * @tc.name: PowerMgrUnittest026
805 * @tc.desc: test IsScreenOn by mock
806 * @tc.type: FUNC
807 */
808 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest026, TestSize.Level2)
809 {
810 sleep(NEXT_WAIT_TIME_S);
811 GTEST_LOG_(INFO) << "PowerMgrUnittest026: start.";
812 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest026:Start.");
813
814 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
815 if (pms == nullptr) {
816 GTEST_LOG_(INFO) << "PowerMgrUnittest026: Failed to get PowerMgrService";
817 }
818
819 EXPECT_CALL(*g_stateAction, GetDisplayState())
820 .Times(::testing::AtLeast(1))
821 .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM));
822 EXPECT_EQ(pms->IsScreenOn(), true);
823
824 ResetMockAction();
825 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest026:End");
826 GTEST_LOG_(INFO) << "PowerMgrUnittest026: end.";
827 }
828
829 /**
830 * @tc.name: PowerMgrUnittest027
831 * @tc.desc: test IsScreenOn by mock
832 * @tc.type: FUNC
833 */
834 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest027, TestSize.Level2)
835 {
836 sleep(NEXT_WAIT_TIME_S);
837 GTEST_LOG_(INFO) << "PowerMgrUnittest027: start.";
838 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest027:Start.");
839
840 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
841 if (pms == nullptr) {
842 GTEST_LOG_(INFO) << "PowerMgrUnittest027: Failed to get PowerMgrService";
843 }
844
845 EXPECT_CALL(*g_stateAction, GetDisplayState())
846 .Times(::testing::AtLeast(1))
847 .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF));
848 EXPECT_EQ(pms->IsScreenOn(), false);
849
850 ResetMockAction();
851 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest027:End.");
852 GTEST_LOG_(INFO) << "PowerMgrUnittest027: end.";
853 }
854
855 /**
856 * @tc.name: PowerMgrUnittest028
857 * @tc.desc: test IsScreenOn by mock
858 * @tc.type: FUNC
859 */
860 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest028, TestSize.Level2)
861 {
862 sleep(NEXT_WAIT_TIME_S);
863 GTEST_LOG_(INFO) << "PowerMgrUnittest028: start.";
864 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest028:Start.");
865
866 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
867 if (pms == nullptr) {
868 GTEST_LOG_(INFO) << "PowerMgrUnittest028: Failed to get PowerMgrService";
869 }
870
871 EXPECT_CALL(*g_stateAction, GetDisplayState())
872 .Times(::testing::AtLeast(1))
873 .WillOnce(::testing::Return(DisplayState::DISPLAY_SUSPEND));
874 EXPECT_EQ(pms->IsScreenOn(), false);
875
876 ResetMockAction();
877 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest028:End.");
878 GTEST_LOG_(INFO) << "PowerMgrUnittest028: end.";
879 }
880
881 /**
882 * @tc.name: PowerMgrUnittest029
883 * @tc.desc: test ForceSuspendDevice by mock
884 * @tc.type: FUNC
885 */
886 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest029, TestSize.Level2)
887 {
888 sleep(NEXT_WAIT_TIME_S);
889 GTEST_LOG_(INFO) << "PowerMgrUnittest029: start.";
890 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest029:Start.");
891
892 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
893 if (pms == nullptr) {
894 GTEST_LOG_(INFO) << "PowerMgrUnittest029: Failed to get PowerMgrService";
895 }
896
897 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true))
898 .Times(1)
899 .WillOnce(::testing::Return(ActionResult::SUCCESS));
900 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
901
902 ResetMockAction();
903 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest029:End.");
904 GTEST_LOG_(INFO) << "PowerMgrUnittest029: end.";
905 }
906
907 /**
908 * @tc.name: PowerMgrUnittest030
909 * @tc.desc: test Screen on RunningLock by mock
910 * @tc.type: FUNC
911 */
912 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest030, TestSize.Level2)
913 {
914 sleep(NEXT_WAIT_TIME_S);
915 GTEST_LOG_(INFO) << "PowerMgrUnittest030: start.";
916 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest030:Start.");
917
918 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
919 if (pms == nullptr) {
920 GTEST_LOG_(INFO) << "PowerMgrUnittest030: Failed to get PowerMgrService";
921 }
922
923 sptr<IRemoteObject> token = new RunningLockTokenStub();
924 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
925 pms->CreateRunningLock(token, info);
926 pms->Lock(token, info, 0);
927 EXPECT_EQ(pms->IsUsed(token), true);
928
929 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
930 sleep(SCREEN_DIM_WAIT_TIME_S + 1);
931
932 pms->UnLock(token);
933 EXPECT_EQ(pms->IsUsed(token), false);
934
935 ResetMockAction();
936 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest030:End.");
937 GTEST_LOG_(INFO) << "PowerMgrUnittest030: end.";
938 }
939
940 /**
941 * @tc.name: PowerMgrUnittest031
942 * @tc.desc: test background RunningLock by mock
943 * @tc.type: FUNC
944 */
945 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest031, TestSize.Level2)
946 {
947 sleep(NEXT_WAIT_TIME_S);
948 GTEST_LOG_(INFO) << "PowerMgrUnittest031: start.";
949 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest031:Start.");
950
951 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
952 if (pms == nullptr) {
953 GTEST_LOG_(INFO) << "PowerMgrUnittest031: Failed to get PowerMgrService";
954 }
955
956 sptr<IRemoteObject> token = new RunningLockTokenStub();
957 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
958 pms->CreateRunningLock(token, info);
959
960 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
961 pms->Lock(token, info, 0);
962 EXPECT_EQ(pms->IsUsed(token), true);
963
964 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
965 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
966 sleep(SLEEP_WAIT_TIME_S + 1);
967
968 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
969 pms->UnLock(token);
970 EXPECT_EQ(pms->IsUsed(token), false);
971
972 ResetMockAction();
973 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest031:End.");
974 GTEST_LOG_(INFO) << "PowerMgrUnittest031: end.";
975 }
976
977 /**
978 * @tc.name: PowerMgrUnittest032
979 * @tc.desc: test proximity RunningLock by mock
980 * @tc.type: FUNC
981 */
982 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest032, TestSize.Level2)
983 {
984 sleep(NEXT_WAIT_TIME_S);
985 GTEST_LOG_(INFO) << "PowerMgrUnittest032: start.";
986 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest032:Start.");
987
988 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
989 if (pms == nullptr) {
990 GTEST_LOG_(INFO) << "PowerMgrUnittest032: Failed to get PowerMgrService";
991 }
992
993 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
994 sptr<IRemoteObject> token = new RunningLockTokenStub();
995 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
996 pms->CreateRunningLock(token, info);
997
998 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
999 pms->Lock(token, info, 0);
1000 EXPECT_EQ(pms->IsUsed(token), true);
1001
1002 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
1003 sleep(SCREEN_DIM_WAIT_TIME_S + 1);
1004
1005 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
1006 pms->UnLock(token);
1007 EXPECT_EQ(pms->IsUsed(token), false);
1008
1009 ResetMockAction();
1010 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest032:End.");
1011 GTEST_LOG_(INFO) << "PowerMgrUnittest032: end.";
1012 }
1013
1014 /**
1015 * @tc.name: PowerMgrUnittest033
1016 * @tc.desc: test RunningLock release by mock
1017 * @tc.type: FUNC
1018 */
1019 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest033, TestSize.Level2)
1020 {
1021 sleep(NEXT_WAIT_TIME_S);
1022 GTEST_LOG_(INFO) << "PowerMgrUnittest033: start.";
1023 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest033:Start.");
1024
1025 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1026 if (pms == nullptr) {
1027 GTEST_LOG_(INFO) << "PowerMgrUnittest033: Failed to get PowerMgrService";
1028 }
1029
1030 sptr<IRemoteObject> token = new RunningLockTokenStub();
1031 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
1032 pms->CreateRunningLock(token, info);
1033 pms->ReleaseRunningLock(token);
1034
1035 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(0);
1036 pms->Lock(token, info, 0);
1037 EXPECT_EQ(pms->IsUsed(token), false);
1038
1039 ResetMockAction();
1040 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest033:End.");
1041 GTEST_LOG_(INFO) << "PowerMgrUnittest033: end.";
1042 }
1043
1044 /**
1045 * @tc.name: PowerMgrUnittest034
1046 * @tc.desc: test RefreshActivity by mock
1047 * @tc.type: FUNC
1048 */
1049 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest034, TestSize.Level2)
1050 {
1051 sleep(NEXT_WAIT_TIME_S);
1052 GTEST_LOG_(INFO) << "PowerMgrUnittest034: start.";
1053 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest034:Start.");
1054
1055 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1056 if (pms == nullptr) {
1057 GTEST_LOG_(INFO) << "PowerMgrUnittest034: Failed to get PowerMgrService";
1058 }
1059
1060 EXPECT_CALL(*g_stateAction, GetDisplayState())
1061 .Times(::testing::AtLeast(1))
1062 .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM));
1063 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
1064 .Times(1)
1065 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1066 EXPECT_CALL(*g_stateAction,
1067 RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, _)).Times(1);
1068 pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, true);
1069
1070 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1);
1071 ResetMockAction();
1072 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest034:End.");
1073 GTEST_LOG_(INFO) << "PowerMgrUnittest034: end.";
1074 }
1075
1076 /**
1077 * @tc.name: PowerMgrUnittest035
1078 * @tc.desc: test RefreshActivity by mock
1079 * @tc.type: FUNC
1080 */
1081 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest035, TestSize.Level2)
1082 {
1083 sleep(NEXT_WAIT_TIME_S);
1084 GTEST_LOG_(INFO) << "PowerMgrUnittest035: start.";
1085 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest035:Start.");
1086
1087 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1088 if (pms == nullptr) {
1089 GTEST_LOG_(INFO) << "PowerMgrUnittest035: Failed to get PowerMgrService";
1090 }
1091
1092 EXPECT_CALL(*g_stateAction, GetDisplayState())
1093 .Times(::testing::AtLeast(1))
1094 .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM));
1095 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
1096 .Times(1)
1097 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1098 EXPECT_CALL(*g_stateAction,
1099 RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, _)).Times(1);
1100 pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, true);
1101
1102 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1);
1103 ResetMockAction();
1104 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest035:End.");
1105 GTEST_LOG_(INFO) << "PowerMgrUnittest035: end.";
1106 }
1107
1108 /**
1109 * @tc.name: PowerMgrUnittest036
1110 * @tc.desc: test RefreshActivity by mock
1111 * @tc.type: FUNC
1112 */
1113 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest036, TestSize.Level2)
1114 {
1115 sleep(NEXT_WAIT_TIME_S);
1116 GTEST_LOG_(INFO) << "PowerMgrUnittest036: start.";
1117 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest036:Start.");
1118
1119 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1120 if (pms == nullptr) {
1121 GTEST_LOG_(INFO) << "PowerMgrUnittest036: Failed to get PowerMgrService";
1122 }
1123
1124 EXPECT_CALL(*g_stateAction, GetDisplayState())
1125 .Times(::testing::AtLeast(1))
1126 .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM));
1127 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
1128 .Times(1)
1129 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1130 EXPECT_CALL(*g_stateAction,
1131 RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, _)).Times(1);
1132 pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, true);
1133
1134 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1);
1135 ResetMockAction();
1136 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest036:End.");
1137 GTEST_LOG_(INFO) << "PowerMgrUnittest036: end.";
1138 }
1139
1140 /**
1141 * @tc.name: PowerMgrUnittest037
1142 * @tc.desc: test RefreshActivity by mock
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest037, TestSize.Level2)
1146 {
1147 sleep(NEXT_WAIT_TIME_S);
1148 GTEST_LOG_(INFO) << "PowerMgrUnittest037: start.";
1149 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest037:Start.");
1150
1151 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1152 if (pms == nullptr) {
1153 GTEST_LOG_(INFO) << "PowerMgrUnittest037: Failed to get PowerMgrService";
1154 }
1155
1156 EXPECT_CALL(*g_stateAction, GetDisplayState())
1157 .Times(::testing::AtLeast(1))
1158 .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM));
1159 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
1160 .Times(1)
1161 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1162 EXPECT_CALL(*g_stateAction,
1163 RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, _)).Times(1);
1164 pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, true);
1165
1166 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1);
1167 ResetMockAction();
1168 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest037:End.");
1169 GTEST_LOG_(INFO) << "PowerMgrUnittest037: end.";
1170 }
1171
1172 /**
1173 * @tc.name: PowerMgrUnittest038
1174 * @tc.desc: test RefreshActivity by mock
1175 * @tc.type: FUNC
1176 */
1177 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest038, TestSize.Level2)
1178 {
1179 sleep(NEXT_WAIT_TIME_S);
1180 GTEST_LOG_(INFO) << "PowerMgrUnittest038: start.";
1181 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest038:Start.");
1182
1183 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1184 if (pms == nullptr) {
1185 GTEST_LOG_(INFO) << "PowerMgrUnittest038: Failed to get PowerMgrService";
1186 }
1187
1188 EXPECT_CALL(*g_stateAction, GetDisplayState())
1189 .Times(::testing::AtLeast(1))
1190 .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM));
1191 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
1192 .Times(1)
1193 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1194 EXPECT_CALL(*g_stateAction,
1195 RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, _)).Times(1);
1196 pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, true);
1197
1198 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1);
1199 ResetMockAction();
1200 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest038:End.");
1201 GTEST_LOG_(INFO) << "PowerMgrUnittest038: end.";
1202 }
1203
1204 /**
1205 * @tc.name: PowerMgrUnittest039
1206 * @tc.desc: test RefreshActivity by mock
1207 * @tc.type: FUNC
1208 */
1209 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest039, TestSize.Level2)
1210 {
1211 UserActivityType abnormaltype = {};
1212 sleep(NEXT_WAIT_TIME_S);
1213 GTEST_LOG_(INFO) << "PowerMgrUnittest039: start.";
1214 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest039:Start.");
1215
1216 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1217 if (pms == nullptr) {
1218 GTEST_LOG_(INFO) << "PowerMgrUnittest039: Failed to get PowerMgrService";
1219 }
1220
1221 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
1222 EXPECT_CALL(*g_stateAction, GetDisplayState())
1223 .Times(::testing::AtLeast(1))
1224 .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM));
1225 EXPECT_CALL(*g_stateAction,
1226 RefreshActivity(0, _, _)).Times(1);
1227 pms->RefreshActivity(0, abnormaltype, true);
1228 sleep(SLEEP_WAIT_TIME_S + 1);
1229 EXPECT_EQ(pms->IsScreenOn(), false);
1230
1231 ResetMockAction();
1232 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest039:End.");
1233 GTEST_LOG_(INFO) << "PowerMgrUnittest039: end.";
1234 }
1235
1236 /**
1237 * @tc.name: PowerMgrUnittest040
1238 * @tc.desc: test RefreshActivity by mock
1239 * @tc.type: FUNC
1240 */
1241 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest040, TestSize.Level2)
1242 {
1243 UserActivityType abnormaltype=UserActivityType(6);
1244 sleep(NEXT_WAIT_TIME_S);
1245 GTEST_LOG_(INFO) << "PowerMgrUnittest040: start.";
1246 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest040:Start.");
1247
1248 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1249 if (pms == nullptr) {
1250 GTEST_LOG_(INFO) << "PowerMgrUnittest040: Failed to get PowerMgrService";
1251 }
1252
1253 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
1254 ON_CALL(*g_stateAction, GetDisplayState())
1255 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
1256 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
1257 ON_CALL(*g_stateAction, GetDisplayState())
1258 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
1259 EXPECT_CALL(*g_stateAction,
1260 RefreshActivity(0, _, _)).Times(0);
1261 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
1262 .Times(::testing::AtLeast(1))
1263 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1264 pms->RefreshActivity(0, abnormaltype, true);
1265 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
1266
1267 ResetMockAction();
1268 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest040:End.");
1269 GTEST_LOG_(INFO) << "PowerMgrUnittest040: end.";
1270 }
1271
1272 /**
1273 * @tc.name: PowerMgrUnittest041
1274 * @tc.desc: test WakeupDevice by mock
1275 * @tc.type: FUNC
1276 */
1277 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest041, TestSize.Level2)
1278 {
1279 int wakeupReason = (static_cast<int>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + 1;
1280 WakeupDeviceType abnormaltype = WakeupDeviceType(wakeupReason);
1281 sleep(NEXT_WAIT_TIME_S);
1282 GTEST_LOG_(INFO) << "PowerMgrUnittest041: start.";
1283 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest041:Start.");
1284
1285 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1286 if (pms == nullptr) {
1287 GTEST_LOG_(INFO) << "PowerMgrUnittest041: Failed to get PowerMgrService";
1288 }
1289
1290 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1291 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
1292 .Times(0);
1293 EXPECT_CALL(*g_stateAction,
1294 Wakeup(0, _,
1295 std::string("test"), _)).Times(0);
1296 pms->WakeupDevice(0, abnormaltype, std::string("test"));
1297 EXPECT_EQ(pms->IsScreenOn(), false);
1298
1299 ResetMockAction();
1300 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest041:End.");
1301 GTEST_LOG_(INFO) << "PowerMgrUnittest041: end.";
1302 }
1303
1304 /**
1305 * @tc.name: PowerMgrUnittest042
1306 * @tc.desc: test WakeupDevice by mock
1307 * @tc.type: FUNC
1308 */
1309 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest042, TestSize.Level2)
1310 {
1311 WakeupDeviceType abnormaltype=WakeupDeviceType(999);
1312 sleep(NEXT_WAIT_TIME_S);
1313 GTEST_LOG_(INFO) << "PowerMgrUnittest042: start.";
1314 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest042:Start.");
1315
1316 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1317 if (pms == nullptr) {
1318 GTEST_LOG_(INFO) << "PowerMgrUnittest042: Failed to get PowerMgrService";
1319 }
1320
1321 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1322 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
1323 .Times(0);
1324 EXPECT_CALL(*g_stateAction,
1325 Wakeup(0, _,
1326 std::string("test"), _)).Times(0);
1327 pms->WakeupDevice(0, abnormaltype, std::string("test"));
1328 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
1329
1330 ResetMockAction();
1331 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest042:End.");
1332 GTEST_LOG_(INFO) << "PowerMgrUnittest042: end.";
1333 }
1334
1335 /**
1336 * @tc.name: PowerMgrUnittest043
1337 * @tc.desc: test WakeupDevice and auto suspend by mock
1338 * @tc.type: FUNC
1339 */
1340 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest043, TestSize.Level2)
1341 {
1342 sleep(NEXT_WAIT_TIME_S);
1343 GTEST_LOG_(INFO) << "PowerMgrUnittest043: start.";
1344 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest043:Start.");
1345
1346 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1347 if (pms == nullptr) {
1348 GTEST_LOG_(INFO) << "PowerMgrUnittest043: Failed to get PowerMgrService";
1349 }
1350
1351 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
1352 ON_CALL(*g_stateAction, GetDisplayState())
1353 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
1354 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
1355 ON_CALL(*g_stateAction, GetDisplayState())
1356 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
1357 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
1358 .Times(::testing::AtLeast(1))
1359 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1360 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
1361
1362 ResetMockAction();
1363 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest043:End.");
1364 GTEST_LOG_(INFO) << "PowerMgrUnittest043: end.";
1365 }
1366
1367 /**
1368 * @tc.name: PowerMgrUnittest044
1369 * @tc.desc: test WakeupDevice and auto suspend by mock
1370 * @tc.type: FUNC
1371 */
1372 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest044, TestSize.Level2)
1373 {
1374 int wakeupReason = (static_cast<int>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + 1;
1375 WakeupDeviceType abnormaltype = WakeupDeviceType(wakeupReason);
1376 sleep(NEXT_WAIT_TIME_S);
1377 GTEST_LOG_(INFO) << "PowerMgrUnittest044: start.";
1378 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest044:Start.");
1379
1380 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1381 if (pms == nullptr) {
1382 GTEST_LOG_(INFO) << "PowerMgrUnittest044: Failed to get PowerMgrService";
1383 }
1384
1385 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
1386 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_))
1387 .Times(::testing::AtLeast(1))
1388 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1389 ON_CALL(*g_stateAction, GetDisplayState())
1390 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
1391 sleep((SCREEN_OFF_WAIT_TIME_S*2/3)/2);
1392 pms->WakeupDevice(0, abnormaltype, std::string("test"));
1393 sleep((SCREEN_OFF_WAIT_TIME_S*2/3)/2 + 1);
1394
1395 ResetMockAction();
1396 GTEST_LOG_(INFO) << "PowerMgrUnittest044: end.";
1397 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest044:End.");
1398 }
1399
1400 /**
1401 * @tc.name: PowerMgrUnittest045
1402 * @tc.desc: test WakeupDevice and auto suspend by mock
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest045, TestSize.Level2)
1406 {
1407 WakeupDeviceType abnormaltype = WakeupDeviceType(999);
1408 sleep(NEXT_WAIT_TIME_S);
1409 GTEST_LOG_(INFO) << "PowerMgrUnittest045: start.";
1410 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest045:Start.");
1411
1412 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1413 if (pms == nullptr) {
1414 GTEST_LOG_(INFO) << "PowerMgrUnittest045: Failed to get PowerMgrService";
1415 }
1416
1417 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
1418 ON_CALL(*g_stateAction, GetDisplayState())
1419 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
1420 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
1421 ON_CALL(*g_stateAction, GetDisplayState())
1422 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
1423 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
1424 .Times(::testing::AtLeast(1))
1425 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1426 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) /2);
1427 pms->WakeupDevice(0, abnormaltype, std::string("test"));
1428 sleep((SCREEN_OFF_WAIT_TIME_S*1/3)/2 + 1);
1429
1430 ResetMockAction();
1431 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest045:End.");
1432 GTEST_LOG_(INFO) << "PowerMgrUnittest045: end.";
1433 }
1434
1435 /**
1436 * @tc.name: PowerMgrUnittest046
1437 * @tc.desc: test RefreshActivity by mock
1438 * @tc.type: FUNC
1439 */
1440 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest046, TestSize.Level2)
1441 {
1442 UserActivityType abnormaltype = UserActivityType(6);
1443 sleep(NEXT_WAIT_TIME_S);
1444 GTEST_LOG_(INFO) << "PowerMgrUnittest046: start.";
1445 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest046:Start.");
1446
1447 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1448 if (pms == nullptr) {
1449 GTEST_LOG_(INFO) << "PowerMgrUnittest046: Failed to get PowerMgrService";
1450 }
1451
1452 EXPECT_CALL(*g_stateAction, GetDisplayState())
1453 .Times(::testing::AtLeast(1))
1454 .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF));
1455 EXPECT_CALL(*g_stateAction,
1456 RefreshActivity(0, _, true)).Times(0);
1457 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2);
1458 pms->RefreshActivity(0, abnormaltype, true);
1459
1460 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1);
1461 ResetMockAction();
1462 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest046:End.");
1463 GTEST_LOG_(INFO) << "PowerMgrUnittest046: end.";
1464 }
1465
1466 /**
1467 * @tc.name: PowerMgrUnittest047
1468 * @tc.desc: test RefreshActivity by mock
1469 * @tc.type: FUNC
1470 */
1471 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest047, TestSize.Level2)
1472 {
1473 UserActivityType abnormaltype = {};
1474 sleep(NEXT_WAIT_TIME_S);
1475 GTEST_LOG_(INFO) << "PowerMgrUnittest047: start.";
1476 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest047:Start.");
1477
1478 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1479 if (pms == nullptr) {
1480 GTEST_LOG_(INFO) << "PowerMgrUnittest047: Failed to get PowerMgrService";
1481 }
1482
1483 EXPECT_CALL(*g_stateAction, GetDisplayState())
1484 .Times(::testing::AtLeast(1))
1485 .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF));
1486 EXPECT_CALL(*g_stateAction,
1487 RefreshActivity(0, _, true)).Times(0);
1488 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2);
1489 pms->RefreshActivity(0, abnormaltype, true);
1490
1491 sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1);
1492 ResetMockAction();
1493 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest047:End.");
1494 GTEST_LOG_(INFO) << "PowerMgrUnittest047: end.";
1495 }
1496
1497 /**
1498 * @tc.name: PowerMgrUnittest048
1499 * @tc.desc: test SuspendDevice by mock
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest048, TestSize.Level2)
1503 {
1504 sleep(NEXT_WAIT_TIME_S);
1505 GTEST_LOG_(INFO) << "PowerMgrUnittest048: start.";
1506 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest048:Start.");
1507
1508 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1509 if (pms == nullptr) {
1510 GTEST_LOG_(INFO) << "PowerMgrUnittest048: Failed to get PowerMgrService";
1511 }
1512
1513 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("test"));
1514 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
1515 .Times(::testing::AtLeast(1))
1516 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1517 EXPECT_CALL(*g_stateAction,
1518 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false));
1519 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _))
1520 .Times(1)
1521 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1522 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1523 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
1524 sleep(SLEEP_WAIT_TIME_S+1);
1525 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
1526
1527 ResetMockAction();
1528 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest048:End");
1529 GTEST_LOG_(INFO) << "PowerMgrUnittest048: end.";
1530 }
1531
1532 /**
1533 * @tc.name: PowerMgrUnittest049
1534 * @tc.desc: test SuspendDevice by mock
1535 * @tc.type: FUNC
1536 */
1537 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest049, TestSize.Level2)
1538 {
1539 SuspendDeviceType abnormaltype = SuspendDeviceType(10);
1540 sleep(NEXT_WAIT_TIME_S);
1541 GTEST_LOG_(INFO) << "PowerMgrUnittest049: start.";
1542 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest049:Start.");
1543
1544 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1545 if (pms == nullptr) {
1546 GTEST_LOG_(INFO) << "PowerMgrUnittest049: Failed to get PowerMgrService";
1547 }
1548
1549 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("test"));
1550 EXPECT_CALL(*g_stateAction,
1551 Suspend(0, _, false)).Times(0);
1552 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_)).Times(0);
1553 pms->SuspendDevice(0, abnormaltype, false);
1554 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
1555
1556 ResetMockAction();
1557 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest049:End.");
1558 GTEST_LOG_(INFO) << "PowerMgrUnittest049: end.";
1559 }
1560
1561 /**
1562 * @tc.name: PowerMgrUnittest050
1563 * @tc.desc: test SuspendDevice by mock
1564 * @tc.type: FUNC
1565 */
1566 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest050, TestSize.Level2)
1567 {
1568 SuspendDeviceType abnormaltype = SuspendDeviceType(999);
1569 sleep(NEXT_WAIT_TIME_S);
1570 GTEST_LOG_(INFO) << "PowerMgrUnittest050: start.";
1571 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest050:Start.");
1572
1573 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1574 if (pms == nullptr) {
1575 GTEST_LOG_(INFO) << "PowerMgrUnittest050: Failed to get PowerMgrService";
1576 }
1577
1578 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("test"));
1579 EXPECT_CALL(*g_stateAction,
1580 Suspend(0, _, false)).Times(0);
1581 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_)).Times(0);
1582 pms->SuspendDevice(0, abnormaltype, false);
1583 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
1584
1585 ResetMockAction();
1586 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest050:End.");
1587 GTEST_LOG_(INFO) << "PowerMgrUnittest050: end.";
1588 }
1589
1590 /**
1591 * @tc.name: PowerMgrUnittest051
1592 * @tc.desc: test SuspendDevice by mock
1593 * @tc.type: FUNC
1594 */
1595 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest051, TestSize.Level2)
1596 {
1597 sleep(NEXT_WAIT_TIME_S);
1598 GTEST_LOG_(INFO) << "PowerMgrUnittest051: start.";
1599 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest051:Start.");
1600
1601 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1602 if (pms == nullptr) {
1603 GTEST_LOG_(INFO) << "PowerMgrUnittest051: Failed to get PowerMgrService";
1604 }
1605
1606 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1607 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
1608 .Times(1)
1609 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1610 EXPECT_CALL(*g_stateAction,
1611 Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false));
1612 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
1613 .Times(1)
1614 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1615 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1616 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
1617 sleep(SLEEP_WAIT_TIME_S+1);
1618 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
1619
1620 ResetMockAction();
1621 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest051:End.");
1622 GTEST_LOG_(INFO) << "PowerMgrUnittest051: end.";
1623 }
1624
1625 /**
1626 * @tc.name: PowerMgrUnittest052
1627 * @tc.desc: test SuspendDevice by mock
1628 * @tc.type: FUNC
1629 */
1630 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest052, TestSize.Level2)
1631 {
1632 SuspendDeviceType abnormaltype = SuspendDeviceType(10);
1633 sleep(NEXT_WAIT_TIME_S);
1634 GTEST_LOG_(INFO) << "PowerMgrUnittest052: start.";
1635 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest052:Start.");
1636
1637 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1638 if (pms == nullptr) {
1639 GTEST_LOG_(INFO) << "PowerMgrUnittest052: Failed to get PowerMgrService";
1640 }
1641
1642 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1643 EXPECT_CALL(*g_stateAction,
1644 Suspend(0, _, false)).Times(0);
1645 pms->SuspendDevice(0, abnormaltype, false);
1646 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
1647
1648 ResetMockAction();
1649 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest052:End.");
1650 GTEST_LOG_(INFO) << "PowerMgrUnittest052: end.";
1651 }
1652
1653 /**
1654 * @tc.name: PowerMgrUnittest053
1655 * @tc.desc: test SuspendDevice by mock
1656 * @tc.type: FUNC
1657 */
1658 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest053, TestSize.Level2)
1659 {
1660 SuspendDeviceType abnormaltype = {};
1661 sleep(NEXT_WAIT_TIME_S);
1662 GTEST_LOG_(INFO) << "PowerMgrUnittest053: start.";
1663 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest053:Start.");
1664
1665 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1666 if (pms == nullptr) {
1667 GTEST_LOG_(INFO) << "PowerMgrUnittest053: Failed to get PowerMgrService";
1668 }
1669
1670 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1671 EXPECT_CALL(*g_stateAction,
1672 Suspend(0, _, false));
1673 pms->SuspendDevice(0, abnormaltype, false);
1674 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
1675
1676 ResetMockAction();
1677 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest053:End.");
1678 GTEST_LOG_(INFO) << "PowerMgrUnittest053: end.";
1679 }
1680
1681 /**
1682 * @tc.name: PowerMgrUnittest054
1683 * @tc.desc: test ForceSuspendDevice by mock during Inactive
1684 * @tc.type: FUNC
1685 */
1686 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest054, TestSize.Level2)
1687 {
1688 sleep(NEXT_WAIT_TIME_S);
1689 GTEST_LOG_(INFO) << "PowerMgrUnittest054: start.";
1690 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest054:Start.");
1691
1692 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1693 if (pms == nullptr) {
1694 GTEST_LOG_(INFO) << "PowerMgrUnittest054: Failed to get PowerMgrService";
1695 }
1696
1697 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1698 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _))
1699 .Times(::testing::AtLeast(1))
1700 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1701 pms->ForceSuspendDevice(0);
1702 sleep(SLEEP_WAIT_TIME_S+1);
1703 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
1704
1705 ResetMockAction();
1706 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest054:End.");
1707 GTEST_LOG_(INFO) << "PowerMgrUnittest054: end.";
1708 }
1709
1710 /**
1711 * @tc.name: PowerMgrUnittest055
1712 * @tc.desc: test auto suspend by mock
1713 * @tc.type: FUNC
1714 */
1715 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest055, TestSize.Level2)
1716 {
1717 sleep(NEXT_WAIT_TIME_S);
1718 GTEST_LOG_(INFO) << "PowerMgrUnittest055: start.";
1719 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest055:Start.");
1720
1721 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1722 if (pms == nullptr) {
1723 GTEST_LOG_(INFO) << "PowerMgrUnittest055: Failed to get PowerMgrService";
1724 }
1725
1726 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID, std::string("test"));
1727 ON_CALL(*g_stateAction, GetDisplayState())
1728 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
1729 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_))
1730 .Times(1)
1731 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1732 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
1733 ON_CALL(*g_stateAction, GetDisplayState())
1734 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
1735 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
1736 .Times(1)
1737 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1738 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
1739
1740 ResetMockAction();
1741 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest055:End.");
1742 GTEST_LOG_(INFO) << "PowerMgrUnittest055: end.";
1743 }
1744
1745 /**
1746 * @tc.name: PowerMgrUnittest056
1747 * @tc.desc: test SCREEN_ON RunningLock by mock
1748 * @tc.type: FUNC
1749 */
1750 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest056, TestSize.Level2)
1751 {
1752 sleep(NEXT_WAIT_TIME_S);
1753 GTEST_LOG_(INFO) << "PowerMgrUnittest056: start.";
1754 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest056:Start.");
1755
1756 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1757 if (pms == nullptr) {
1758 GTEST_LOG_(INFO) << "PowerMgrUnittest056: Failed to get PowerMgrService";
1759 }
1760
1761 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
1762 sptr<IRemoteObject> token = new RunningLockTokenStub();
1763 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
1764 pms->CreateRunningLock(token, info);
1765
1766 pms->Lock(token, info, 0);
1767 EXPECT_EQ(pms->IsUsed(token), true);
1768
1769 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
1770 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
1771 ON_CALL(*g_stateAction, GetDisplayState())
1772 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
1773 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
1774
1775 pms->UnLock(token);
1776 EXPECT_EQ(pms->IsUsed(token), false);
1777 ResetMockAction();
1778 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest056:End.");
1779 GTEST_LOG_(INFO) << "PowerMgrUnittest056: end.";
1780 }
1781
1782 /**
1783 * @tc.name: PowerMgrUnittest057
1784 * @tc.desc: test SCREEN_ON RunningLock by mock
1785 * @tc.type: FUNC
1786 */
1787 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest057, TestSize.Level2)
1788 {
1789 sleep(NEXT_WAIT_TIME_S);
1790 GTEST_LOG_(INFO) << "PowerMgrUnittest057: start.";
1791 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest057:Start.");
1792
1793 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1794 if (pms == nullptr) {
1795 GTEST_LOG_(INFO) << "PowerMgrUnittest057: Failed to get PowerMgrService";
1796 }
1797
1798 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1799 sptr<IRemoteObject> token = new RunningLockTokenStub();
1800 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
1801 pms->CreateRunningLock(token, info);
1802 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
1803 .Times(1)
1804 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1805 pms->Lock(token, info, 0);
1806 EXPECT_EQ(pms->IsUsed(token), true);
1807 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
1808
1809 pms->UnLock(token);
1810 EXPECT_EQ(pms->IsUsed(token), false);
1811 ResetMockAction();
1812 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest057:End.");
1813 GTEST_LOG_(INFO) << "PowerMgrUnittest057: end.";
1814 }
1815
1816 /**
1817 * @tc.name: PowerMgrUnittest058
1818 * @tc.desc: test Auto DIM by mock after 10min
1819 * @tc.type: FUNC
1820 */
1821 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest058, TestSize.Level2)
1822 {
1823 int64_t time =600000;
1824 sleep(NEXT_WAIT_TIME_S);
1825 GTEST_LOG_(INFO) << "PowerMgrUnittest058: start.";
1826
1827 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1828 if (pms == nullptr) {
1829 GTEST_LOG_(INFO) << "PowerMgrUnittest058: Failed to get PowerMgrService";
1830 }
1831 ON_CALL(*g_stateAction, GetDisplayState())
1832 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
1833 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_))
1834 .Times(1)
1835 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1836 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
1837 .Times(1)
1838 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1839 pms->SetDisplayOffTime(time);
1840 sleep(time/1000-2);
1841 ON_CALL(*g_stateAction, GetDisplayState())
1842 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
1843 sleep(3);
1844 ResetMockAction();
1845 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
1846 GTEST_LOG_(INFO) << "PowerMgrUnittest058: end.";
1847 }
1848
1849 /**
1850 * @tc.name: PowerMgrUnittest059
1851 * @tc.desc: test Screen RunningLock by mock
1852 * @tc.type: FUNC
1853 */
1854 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest059, TestSize.Level2)
1855 {
1856 sleep(NEXT_WAIT_TIME_S);
1857 GTEST_LOG_(INFO) << "PowerMgrUnittest059: start.";
1858 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest059:Start.");
1859
1860 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1861 if (pms == nullptr) {
1862 GTEST_LOG_(INFO) << "PowerMgrUnittest059: Failed to get PowerMgrService";
1863 }
1864
1865 sptr<IRemoteObject> token = new RunningLockTokenStub();
1866 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
1867 pms->CreateRunningLock(token, info);
1868 pms->Lock(token, info, 0);
1869 EXPECT_EQ(pms->IsUsed(token), true);
1870
1871 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
1872 sleep(SCREEN_DIM_WAIT_TIME_S + 1);
1873
1874 pms->UnLock(token);
1875 EXPECT_EQ(pms->IsUsed(token), false);
1876
1877 ResetMockAction();
1878 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest059:End.");
1879 GTEST_LOG_(INFO) << "PowerMgrUnittest059: end.";
1880 }
1881
1882 /**
1883 * @tc.name: PowerMgrUnittest060
1884 * @tc.desc: test Screen RunningLock by mock
1885 * @tc.type: FUNC
1886 */
1887 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest060, TestSize.Level2)
1888 {
1889 sleep(NEXT_WAIT_TIME_S);
1890 GTEST_LOG_(INFO) << "PowerMgrUnittest060: start.";
1891 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest060:Start.");
1892
1893 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1894 if (pms == nullptr) {
1895 GTEST_LOG_(INFO) << "PowerMgrUnittest060: Failed to get PowerMgrService";
1896 }
1897
1898 sptr<IRemoteObject> token = new RunningLockTokenStub();
1899 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
1900 pms->CreateRunningLock(token, info);
1901 pms->Lock(token, info, 0);
1902 EXPECT_EQ(pms->IsUsed(token), true);
1903
1904 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_)).Times(0);
1905 sleep(SLEEP_WAIT_TIME_S*10);
1906
1907 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_)).Times(0);
1908 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
1909
1910
1911 ResetMockAction();
1912 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest060:End.");
1913 GTEST_LOG_(INFO) << "PowerMgrUnittest060: end.";
1914 }
1915
1916 /**
1917 * @tc.name: PowerMgrUnittest061
1918 * @tc.desc: test Screen on RunningLock by mock
1919 * @tc.type: FUNC
1920 */
1921 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest061, TestSize.Level2)
1922 {
1923 int i;
1924 sleep(NEXT_WAIT_TIME_S);
1925 GTEST_LOG_(INFO) << "PowerMgrUnittest061: start.";
1926 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest061:Start.");
1927
1928 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1929 if (pms == nullptr) {
1930 GTEST_LOG_(INFO) << "PowerMgrUnittest061: Failed to get PowerMgrService";
1931 }
1932
1933 sptr<IRemoteObject> token = new RunningLockTokenStub();
1934 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
1935 pms->CreateRunningLock(token, info);
1936 for (i=0; i<10; i++) {
1937 pms->Lock(token, info, 0);
1938 EXPECT_EQ(pms->IsUsed(token), true);
1939
1940 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
1941 sleep(SCREEN_OFF_WAIT_TIME_S + 1);
1942
1943 pms->UnLock(token);
1944 EXPECT_EQ(pms->IsUsed(token), false);
1945 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
1946 }
1947 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
1948
1949 ResetMockAction();
1950 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest061:End.");
1951 GTEST_LOG_(INFO) << "PowerMgrUnittest061: end.";
1952 }
1953
1954 /**
1955 * @tc.name: PowerMgrUnittest062
1956 * @tc.desc: test Screen RunningLock by mock
1957 * @tc.type: FUNC
1958 */
1959 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest062, TestSize.Level2)
1960 {
1961 sleep(NEXT_WAIT_TIME_S);
1962 GTEST_LOG_(INFO) << "PowerMgrUnittest062: start.";
1963 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest062:Start.");
1964
1965 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1966 if (pms == nullptr) {
1967 GTEST_LOG_(INFO) << "PowerMgrUnittest062: Failed to get PowerMgrService";
1968 }
1969
1970 sptr<IRemoteObject> token = new RunningLockTokenStub();
1971 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
1972 pms->CreateRunningLock(token, info);
1973
1974 pms->Lock(token, info, 0);
1975 EXPECT_EQ(pms->IsUsed(token), true);
1976
1977 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
1978 .Times(::testing::AtLeast(1))
1979 .WillOnce(::testing::Return(ActionResult::SUCCESS));
1980
1981 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(1);
1982 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
1983 sleep(SLEEP_WAIT_TIME_S + 1);
1984
1985 pms->UnLock(token);
1986 EXPECT_EQ(pms->IsUsed(token), false);
1987 sleep(SLEEP_WAIT_TIME_S + 1);
1988 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
1989
1990 ResetMockAction();
1991 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest062:End.");
1992 GTEST_LOG_(INFO) << "PowerMgrUnittest062: end.";
1993 }
1994
1995 /**
1996 * @tc.name: PowerMgrUnittest063
1997 * @tc.desc: test Screen RunningLock by mock
1998 * @tc.type: FUNC
1999 */
2000 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest063, TestSize.Level2)
2001 {
2002 sleep(NEXT_WAIT_TIME_S);
2003 GTEST_LOG_(INFO) << "PowerMgrUnittest063: start.";
2004 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest063:Start.");
2005
2006 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2007 if (pms == nullptr) {
2008 GTEST_LOG_(INFO) << "PowerMgrUnittest063: Failed to get PowerMgrService";
2009 }
2010
2011 sptr<IRemoteObject> token = new RunningLockTokenStub();
2012 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
2013 pms->CreateRunningLock(token, info);
2014
2015 pms->Lock(token, info, 0);
2016 EXPECT_EQ(pms->IsUsed(token), true);
2017
2018
2019 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true))
2020 .Times(1)
2021 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2022 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
2023 sleep(SLEEP_WAIT_TIME_S + 1);
2024
2025 pms->UnLock(token);
2026 EXPECT_EQ(pms->IsUsed(token), false);
2027 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
2028
2029 ResetMockAction();
2030 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest063:End.");
2031 GTEST_LOG_(INFO) << "PowerMgrUnittest063: end.";
2032 }
2033
2034 /**
2035 * @tc.name: PowerMgrUnittest064
2036 * @tc.desc: test Screen RunningLock by mock
2037 * @tc.type: FUNC
2038 */
2039 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest064, TestSize.Level2)
2040 {
2041 sleep(NEXT_WAIT_TIME_S);
2042 GTEST_LOG_(INFO) << "PowerMgrUnittest064: start.";
2043 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest063:Start.");
2044
2045 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2046 if (pms == nullptr) {
2047 GTEST_LOG_(INFO) << "PowerMgrUnittest064: Failed to get PowerMgrService";
2048 }
2049
2050 sptr<IRemoteObject> token = new RunningLockTokenStub();
2051 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
2052 pms->CreateRunningLock(token, info);
2053
2054 pms->Lock(token, info, 0);
2055 EXPECT_EQ(pms->IsUsed(token), true);
2056
2057 EXPECT_CALL(*g_stateAction, Suspend(_, _, _)).Times(0);
2058
2059 EXPECT_CALL(*g_stateAction,
2060 Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN,
2061 std::string("test"), _)).Times(1);
2062 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
2063
2064 pms->UnLock(token);
2065 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
2066
2067 ResetMockAction();
2068 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest064:End.");
2069 GTEST_LOG_(INFO) << "PowerMgrUnittest064: end.";
2070 }
2071
2072 /**
2073 * @tc.name: PowerMgrUnittest065
2074 * @tc.desc: test background RunningLock by mock
2075 * @tc.type: FUNC
2076 */
2077 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest065, TestSize.Level2)
2078 {
2079 sleep(NEXT_WAIT_TIME_S);
2080 GTEST_LOG_(INFO) << "PowerMgrUnittest065: start.";
2081 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest065:Start.");
2082
2083 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2084 if (pms == nullptr) {
2085 GTEST_LOG_(INFO) << "PowerMgrUnittest065: Failed to get PowerMgrService";
2086 }
2087
2088 sptr<IRemoteObject> token = new RunningLockTokenStub();
2089 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
2090 pms->CreateRunningLock(token, info);
2091
2092 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true))
2093 .Times(1)
2094 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2095 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
2096 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
2097 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
2098 pms->Lock(token, info, 0);
2099 EXPECT_EQ(pms->IsUsed(token), true);
2100
2101 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
2102 pms->UnLock(token);
2103
2104 ResetMockAction();
2105 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest065:End.");
2106 GTEST_LOG_(INFO) << "PowerMgrUnittest065: end.";
2107 }
2108
2109 /**
2110 * @tc.name: PowerMgrUnittest066
2111 * @tc.desc: test background RunningLock by mock
2112 * @tc.type: FUNC
2113 */
2114 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest066, TestSize.Level2)
2115 {
2116 sleep(NEXT_WAIT_TIME_S);
2117 GTEST_LOG_(INFO) << "PowerMgrUnittest066: start.";
2118 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest066:Start.");
2119
2120 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2121 if (pms == nullptr) {
2122 GTEST_LOG_(INFO) << "PowerMgrUnittest066: Failed to get PowerMgrService";
2123 }
2124
2125 sptr<IRemoteObject> token = new RunningLockTokenStub();
2126 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
2127 pms->CreateRunningLock(token, info);
2128
2129 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
2130 pms->Lock(token, info, 0);
2131 EXPECT_EQ(pms->IsUsed(token), true);
2132
2133 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
2134 pms->UnLock(token);
2135 ON_CALL(*g_stateAction, GetDisplayState())
2136 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2137 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
2138 ON_CALL(*g_stateAction, GetDisplayState())
2139 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2140 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
2141 ON_CALL(*g_stateAction, GetDisplayState())
2142 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2143 EXPECT_EQ(pms->IsUsed(token), false);
2144 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(1);
2145 sleep(SLEEP_WAIT_TIME_S + 1);
2146 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
2147
2148 ResetMockAction();
2149 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest066:End.");
2150 GTEST_LOG_(INFO) << "PowerMgrUnittest066: end.";
2151 }
2152
2153 /**
2154 * @tc.name: PowerMgrUnittest067
2155 * @tc.desc: test background RunningLock by mock
2156 * @tc.type: FUNC
2157 */
2158 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest067, TestSize.Level2)
2159 {
2160 sleep(NEXT_WAIT_TIME_S);
2161 GTEST_LOG_(INFO) << "PowerMgrUnittest067: start.";
2162 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest067:Start.");
2163
2164 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2165 if (pms == nullptr) {
2166 GTEST_LOG_(INFO) << "PowerMgrUnittest067: Failed to get PowerMgrService";
2167 }
2168
2169 sptr<IRemoteObject> token = new RunningLockTokenStub();
2170 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
2171 pms->CreateRunningLock(token, info);
2172 pms->Lock(token, info, 0);
2173 EXPECT_EQ(pms->IsUsed(token), true);
2174 ON_CALL(*g_stateAction, GetDisplayState())
2175 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2176 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
2177 ON_CALL(*g_stateAction, GetDisplayState())
2178 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2179
2180 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2181 .Times(1)
2182 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2183 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
2184 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
2185 sleep(SLEEP_WAIT_TIME_S*10);
2186
2187 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
2188 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
2189
2190
2191 ResetMockAction();
2192 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest067:End.");
2193 GTEST_LOG_(INFO) << "PowerMgrUnittest067: end.";
2194 }
2195
2196 /**
2197 * @tc.name: PowerMgrUnittest068
2198 * @tc.desc: test background RunningLock by mock
2199 * @tc.type: FUNC
2200 */
2201 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest068, TestSize.Level2)
2202 {
2203 int i;
2204 sleep(NEXT_WAIT_TIME_S);
2205 GTEST_LOG_(INFO) << "PowerMgrUnittest068: start.";
2206 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest068:Start.");
2207
2208 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2209 if (pms == nullptr) {
2210 GTEST_LOG_(INFO) << "PowerMgrUnittest068: Failed to get PowerMgrService";
2211 }
2212
2213 sptr<IRemoteObject> token = new RunningLockTokenStub();
2214 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
2215 ON_CALL(*g_stateAction, GetDisplayState())
2216 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2217 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
2218 ON_CALL(*g_stateAction, GetDisplayState())
2219 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2220 pms->CreateRunningLock(token, info);
2221 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2222 .Times(1)
2223 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2224 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
2225 pms->Lock(token, info, 0);
2226 EXPECT_EQ(pms->IsUsed(token), true);
2227 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
2228 pms->UnLock(token);
2229 EXPECT_EQ(pms->IsUsed(token), false);
2230 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
2231 for (i=0; i<10; i++) {
2232 pms->Lock(token, info, 0);
2233 EXPECT_EQ(pms->IsUsed(token), true);
2234 sleep(SCREEN_OFF_WAIT_TIME_S + 1);
2235
2236 pms->UnLock(token);
2237 EXPECT_EQ(pms->IsUsed(token), false);
2238 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
2239 }
2240 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
2241
2242 ResetMockAction();
2243 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest068:End.");
2244 GTEST_LOG_(INFO) << "PowerMgrUnittest068: end.";
2245 }
2246
2247 /**
2248 * @tc.name: PowerMgrUnittest069
2249 * @tc.desc: test background RunningLock by mock
2250 * @tc.type: FUNC
2251 */
2252 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest069, TestSize.Level2)
2253 {
2254 sleep(NEXT_WAIT_TIME_S);
2255 GTEST_LOG_(INFO) << "PowerMgrUnittest069: start.";
2256 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest069:Start.");
2257
2258 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2259 if (pms == nullptr) {
2260 GTEST_LOG_(INFO) << "PowerMgrUnittest069: Failed to get PowerMgrService";
2261 }
2262
2263 sptr<IRemoteObject> token = new RunningLockTokenStub();
2264 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
2265 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
2266 sleep(SLEEP_WAIT_TIME_S);
2267 pms->CreateRunningLock(token, info);
2268 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
2269 pms->Lock(token, info, 0);
2270 EXPECT_EQ(pms->IsUsed(token), true);
2271 sleep(SLEEP_WAIT_TIME_S + 1);
2272 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
2273 .Times(1)
2274 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2275 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
2276 sleep(SLEEP_WAIT_TIME_S + 1);
2277 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_)).Times(0);
2278 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
2279 pms->UnLock(token);
2280 EXPECT_EQ(pms->IsUsed(token), false);
2281 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
2282
2283 ResetMockAction();
2284 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest069:End");
2285 GTEST_LOG_(INFO) << "PowerMgrUnittest069: end.";
2286 }
2287
2288 /**
2289 * @tc.name: PowerMgrUnittest070
2290 * @tc.desc: test background RunningLock by mock
2291 * @tc.type: FUNC
2292 */
2293 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest070, TestSize.Level2)
2294 {
2295 sleep(NEXT_WAIT_TIME_S);
2296 GTEST_LOG_(INFO) << "PowerMgrUnittest070: start.";
2297 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest070:Start.");
2298
2299 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2300 if (pms == nullptr) {
2301 GTEST_LOG_(INFO) << "PowerMgrUnittest070: Failed to get PowerMgrService";
2302 }
2303
2304 sptr<IRemoteObject> token = new RunningLockTokenStub();
2305 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
2306 pms->CreateRunningLock(token, info);
2307
2308 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
2309 pms->Lock(token, info, 0);
2310 EXPECT_EQ(pms->IsUsed(token), true);
2311 sleep(SLEEP_WAIT_TIME_S + 1);
2312 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true))
2313 .Times(1)
2314 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2315 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
2316 sleep(SLEEP_WAIT_TIME_S + 1);
2317 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
2318 pms->UnLock(token);
2319 EXPECT_EQ(pms->IsUsed(token), false);
2320 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
2321
2322 ResetMockAction();
2323 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest070:End.");
2324 GTEST_LOG_(INFO) << "PowerMgrUnittest070: end.";
2325 }
2326
2327 /**
2328 * @tc.name: PowerMgrUnittest071
2329 * @tc.desc: test proximity screen control RunningLock by mock
2330 * @tc.type: FUNC
2331 */
2332 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest071, TestSize.Level2)
2333 {
2334 sleep(NEXT_WAIT_TIME_S);
2335 GTEST_LOG_(INFO) << "PowerMgrUnittest071: start.";
2336 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest071:Start.");
2337
2338 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2339 if (pms == nullptr) {
2340 GTEST_LOG_(INFO) << "PowerMgrUnittest071: Failed to get PowerMgrService";
2341 }
2342
2343 sptr<IRemoteObject> token = new RunningLockTokenStub();
2344 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2345 pms->CreateRunningLock(token, info);
2346 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2347 .Times(::testing::AtLeast(1))
2348 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2349 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
2350 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
2351 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
2352 .Times(1)
2353 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2354 sleep(SCREEN_OFF_WAIT_TIME_S + 1);
2355 pms->Lock(token, info, 0);
2356 EXPECT_EQ(pms->IsUsed(token), true);
2357 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
2358 pms->UnLock(token);
2359 EXPECT_EQ(pms->IsUsed(token), false);
2360
2361 ResetMockAction();
2362 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest071:End.");
2363 GTEST_LOG_(INFO) << "PowerMgrUnittest071: end.";
2364 }
2365
2366
2367 /**
2368 * @tc.name: PowerMgrUnittest072
2369 * @tc.desc: test proximity screen control RunningLock by mock
2370 * @tc.type: FUNC
2371 */
2372 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest072, TestSize.Level2)
2373 {
2374 sleep(NEXT_WAIT_TIME_S);
2375 GTEST_LOG_(INFO) << "PowerMgrUnittest072: start.";
2376 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest072:Start.");
2377
2378 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2379 if (pms == nullptr) {
2380 GTEST_LOG_(INFO) << "PowerMgrUnittest072: Failed to get PowerMgrService";
2381 }
2382
2383 sptr<IRemoteObject> token = new RunningLockTokenStub();
2384 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2385 pms->CreateRunningLock(token, info);
2386 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true))
2387 .Times(1)
2388 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2389 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
2390 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
2391 .Times(1)
2392 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2393 sleep(SCREEN_OFF_WAIT_TIME_S + 1);
2394 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
2395 pms->Lock(token, info, 0);
2396 EXPECT_EQ(pms->IsUsed(token), true);
2397 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
2398 pms->UnLock(token);
2399 EXPECT_EQ(pms->IsUsed(token), false);
2400
2401 ResetMockAction();
2402 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest072:End.");
2403 GTEST_LOG_(INFO) << "PowerMgrUnittest072: end.";
2404 }
2405
2406 /**
2407 * @tc.name: PowerMgrUnittest073
2408 * @tc.desc: test proximity screen control RunningLock by mock
2409 * @tc.type: FUNC
2410 */
2411 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest073, TestSize.Level2)
2412 {
2413 sleep(NEXT_WAIT_TIME_S);
2414 GTEST_LOG_(INFO) << "PowerMgrUnittest073: start.";
2415 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest073:Start.");
2416
2417 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2418 if (pms == nullptr) {
2419 GTEST_LOG_(INFO) << "PowerMgrUnittest073: Failed to get PowerMgrService";
2420 }
2421
2422 sptr<IRemoteObject> token = new RunningLockTokenStub();
2423 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2424 pms->CreateRunningLock(token, info);
2425 pms->Lock(token, info, 0);
2426 EXPECT_EQ(pms->IsUsed(token), true);
2427 sleep(SLEEP_WAIT_TIME_S);
2428 pms->UnLock(token);
2429 EXPECT_EQ(pms->IsUsed(token), false);
2430 ON_CALL(*g_stateAction, GetDisplayState())
2431 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2432 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
2433 ON_CALL(*g_stateAction, GetDisplayState())
2434 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2435 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2436 .Times(::testing::AtLeast(1))
2437 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2438 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
2439 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
2440 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
2441 .Times(1)
2442 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2443 ON_CALL(*g_stateAction, GetDisplayState())
2444 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2445 sleep(SLEEP_WAIT_TIME_S + 1);
2446 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
2447
2448 ResetMockAction();
2449 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest073:End.");
2450 GTEST_LOG_(INFO) << "PowerMgrUnittest073: end.";
2451 }
2452
2453 /**
2454 * @tc.name: PowerMgrUnittest074
2455 * @tc.desc: test proximity RunningLock by mock
2456 * @tc.type: FUNC
2457 */
2458 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest074, TestSize.Level2)
2459 {
2460 sleep(NEXT_WAIT_TIME_S);
2461 GTEST_LOG_(INFO) << "PowerMgrUnittest074: start.";
2462 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest074:Start.");
2463
2464 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2465 if (pms == nullptr) {
2466 GTEST_LOG_(INFO) << "PowerMgrUnittest074: Failed to get PowerMgrService";
2467 }
2468
2469 sptr<IRemoteObject> token = new RunningLockTokenStub();
2470 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2471 pms->CreateRunningLock(token, info);
2472 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
2473 pms->Lock(token, info, 0);
2474 EXPECT_EQ(pms->IsUsed(token), true);
2475 sleep(SCREEN_OFF_WAIT_TIME_S+1);
2476 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
2477 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2478 .Times(1)
2479 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2480 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
2481 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
2482
2483 ResetMockAction();
2484 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest074:End.");
2485 GTEST_LOG_(INFO) << "PowerMgrUnittest074: end.";
2486 }
2487
2488 /**
2489 * @tc.name: PowerMgrUnittest075
2490 * @tc.desc: test proximity RunningLock by mock
2491 * @tc.type: FUNC
2492 */
2493 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest075, TestSize.Level2)
2494 {
2495 sleep(NEXT_WAIT_TIME_S);
2496 GTEST_LOG_(INFO) << "PowerMgrUnittest075: start.";
2497 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest075:Start.");
2498
2499 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2500 if (pms == nullptr) {
2501 GTEST_LOG_(INFO) << "PowerMgrUnittest075: Failed to get PowerMgrService";
2502 }
2503
2504 sptr<IRemoteObject> token = new RunningLockTokenStub();
2505 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2506 pms->CreateRunningLock(token, info);
2507 pms->Lock(token, info, 0);
2508 EXPECT_EQ(pms->IsUsed(token), true);
2509 sleep(SLEEP_WAIT_TIME_S*10);
2510 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
2511
2512 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2513 .Times(1)
2514 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2515 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
2516 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
2517 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
2518
2519 ResetMockAction();
2520 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest075:End.");
2521 GTEST_LOG_(INFO) << "PowerMgrUnittest075: end.";
2522 }
2523
2524 /**
2525 * @tc.name: PowerMgrUnittest076
2526 * @tc.desc: test proximity RunningLock by mock
2527 * @tc.type: FUNC
2528 */
2529 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest076, TestSize.Level2)
2530 {
2531 int i;
2532 sleep(NEXT_WAIT_TIME_S);
2533 GTEST_LOG_(INFO) << "PowerMgrUnittest076: start.";
2534 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest076:Start.");
2535
2536 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2537 if (pms == nullptr) {
2538 GTEST_LOG_(INFO) << "PowerMgrUnittest076: Failed to get PowerMgrService";
2539 }
2540
2541 sptr<IRemoteObject> token = new RunningLockTokenStub();
2542 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2543 pms->CreateRunningLock(token, info);
2544 for (i=0; i<10; i++) {
2545 pms->Lock(token, info, 0);
2546 EXPECT_EQ(pms->IsUsed(token), true);
2547 sleep(SCREEN_OFF_WAIT_TIME_S + 1);
2548 pms->UnLock(token);
2549 EXPECT_EQ(pms->IsUsed(token), false);
2550 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
2551 }
2552 pms->Lock(token, info, 0);
2553 EXPECT_EQ(pms->IsUsed(token), true);
2554 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2555 .Times(1)
2556 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2557 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
2558 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
2559 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
2560
2561 ResetMockAction();
2562 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest076:End.");
2563 GTEST_LOG_(INFO) << "PowerMgrUnittest076: end.";
2564 }
2565
2566 /**
2567 * @tc.name: PowerMgrUnittest077
2568 * @tc.desc: test proximity RunningLock by mock
2569 * @tc.type: FUNC
2570 */
2571 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest077, TestSize.Level2)
2572 {
2573 sleep(NEXT_WAIT_TIME_S);
2574 GTEST_LOG_(INFO) << "PowerMgrUnittest077: start.";
2575 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest077:Start.");
2576
2577 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2578 if (pms == nullptr) {
2579 GTEST_LOG_(INFO) << "PowerMgrUnittest077: Failed to get PowerMgrService";
2580 }
2581
2582 sptr<IRemoteObject> token = new RunningLockTokenStub();
2583 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2584 pms->CreateRunningLock(token, info);
2585 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
2586 pms->Lock(token, info, 0);
2587 EXPECT_EQ(pms->IsUsed(token), true);
2588 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2589 .Times(::testing::AtLeast(1))
2590 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2591 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
2592 .Times(1)
2593 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2594 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
2595 sleep(SLEEP_WAIT_TIME_S + 1);
2596 ON_CALL(*g_stateAction, GetDisplayState())
2597 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2598 sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1);
2599 ON_CALL(*g_stateAction, GetDisplayState())
2600 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2601 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
2602 ON_CALL(*g_stateAction, GetDisplayState())
2603 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2604 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
2605
2606 ResetMockAction();
2607 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest077:End.");
2608 GTEST_LOG_(INFO) << "PowerMgrUnittest077: end.";
2609 }
2610
2611 /**
2612 * @tc.name: PowerMgrUnittest078
2613 * @tc.desc: test proximity RunningLock by mock
2614 * @tc.type: FUNC
2615 */
2616 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest078, TestSize.Level2)
2617 {
2618 sleep(NEXT_WAIT_TIME_S);
2619 GTEST_LOG_(INFO) << "PowerMgrUnittest078: start.";
2620 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest078:Start.");
2621
2622 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2623 if (pms == nullptr) {
2624 GTEST_LOG_(INFO) << "PowerMgrUnittest078: Failed to get PowerMgrService";
2625 }
2626
2627 sptr<IRemoteObject> token = new RunningLockTokenStub();
2628 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2629 pms->CreateRunningLock(token, info);
2630 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
2631 pms->Lock(token, info, 0);
2632 EXPECT_EQ(pms->IsUsed(token), true);
2633 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true))
2634 .Times(1)
2635 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2636 pms->ForceSuspendDevice(0);
2637 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
2638 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
2639 pms->UnLock(token);
2640 EXPECT_EQ(pms->IsUsed(token), false);
2641
2642 ResetMockAction();
2643 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest078:End.");
2644 GTEST_LOG_(INFO) << "PowerMgrUnittest078: end.";
2645 }
2646
2647 /**
2648 * @tc.name: PowerMgrUnittest079
2649 * @tc.desc: test proximity RunningLock by mock
2650 * @tc.type: FUNC
2651 */
2652 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest079, TestSize.Level2)
2653 {
2654 sleep(NEXT_WAIT_TIME_S);
2655 GTEST_LOG_(INFO) << "PowerMgrUnittest079: start.";
2656 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest079:Start.");
2657
2658 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2659 if (pms == nullptr) {
2660 GTEST_LOG_(INFO) << "PowerMgrUnittest079: Failed to get PowerMgrService";
2661 }
2662
2663 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
2664 sptr<IRemoteObject> token = new RunningLockTokenStub();
2665 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
2666 pms->CreateRunningLock(token, info);
2667 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
2668 pms->Lock(token, info, 0);
2669 EXPECT_EQ(pms->IsUsed(token), true);
2670 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
2671 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
2672
2673 ResetMockAction();
2674 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest079:End.");
2675 GTEST_LOG_(INFO) << "PowerMgrUnittest079: end.";
2676 }
2677
2678 /**
2679 * @tc.name: PowerMgrUnittest080
2680 * @tc.desc: test Auto SuspendDevice by mock after 15s
2681 * @tc.type: FUNC
2682 */
2683 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest080, TestSize.Level2)
2684 {
2685 int64_t time =15000;
2686 sleep(NEXT_WAIT_TIME_S);
2687 GTEST_LOG_(INFO) << "PowerMgrUnittest080: start.";
2688 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest080:Start.");
2689
2690 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2691 if (pms == nullptr) {
2692 GTEST_LOG_(INFO) << "PowerMgrUnittest080: Failed to get PowerMgrService";
2693 }
2694
2695 pms->SetDisplayOffTime(time);
2696 ON_CALL(*g_stateAction, GetDisplayState())
2697 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2698 sleep(((time/1000)*2/3)+1);
2699 ON_CALL(*g_stateAction, GetDisplayState())
2700 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2701 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2702 .Times(::testing::AtLeast(1))
2703 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2704 sleep(time/1000*1/3+1);
2705 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
2706 .Times(1)
2707 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2708 ON_CALL(*g_stateAction, GetDisplayState())
2709 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2710 sleep(SLEEP_WAIT_TIME_S+1);
2711
2712 ResetMockAction();
2713 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest080:End.");
2714 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
2715 GTEST_LOG_(INFO) << "PowerMgrUnittest080: end.";
2716 }
2717
2718 /**
2719 * @tc.name: PowerMgrUnittest081
2720 * @tc.desc: test Auto SuspendDevice by mock after 30s
2721 * @tc.type: FUNC
2722 */
2723 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest081, TestSize.Level2)
2724 {
2725 int64_t time =30000;
2726 sleep(NEXT_WAIT_TIME_S);
2727 GTEST_LOG_(INFO) << "PowerMgrUnittest081: start.";
2728 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest081:Start.");
2729
2730 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2731 if (pms == nullptr) {
2732 GTEST_LOG_(INFO) << "PowerMgrUnittest081: Failed to get PowerMgrService";
2733 }
2734
2735 pms->SetDisplayOffTime(time);
2736 ON_CALL(*g_stateAction, GetDisplayState())
2737 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2738 sleep(((time/1000)*2/3)+1);
2739 ON_CALL(*g_stateAction, GetDisplayState())
2740 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2741 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2742 .Times(::testing::AtLeast(1))
2743 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2744 sleep(((time/1000)*1/3)+1);
2745 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
2746 .Times(1)
2747 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2748 ON_CALL(*g_stateAction, GetDisplayState())
2749 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2750 sleep(SLEEP_WAIT_TIME_S+1);
2751
2752 ResetMockAction();
2753 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest081:End");
2754 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
2755 GTEST_LOG_(INFO) << "PowerMgrUnittest081: end.";
2756 }
2757
2758 /**
2759 * @tc.name: PowerMgrUnittest082
2760 * @tc.desc: test Auto SuspendDevice by mock after 1min
2761 * @tc.type: FUNC
2762 */
2763 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest082, TestSize.Level2)
2764 {
2765 int64_t time =60000;
2766 sleep(NEXT_WAIT_TIME_S);
2767 GTEST_LOG_(INFO) << "PowerMgrUnittest082: start.";
2768
2769 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2770 if (pms == nullptr) {
2771 GTEST_LOG_(INFO) << "PowerMgrUnittest082: Failed to get PowerMgrService";
2772 }
2773
2774 pms->SetDisplayOffTime(time);
2775 ON_CALL(*g_stateAction, GetDisplayState())
2776 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2777 sleep(((time/1000)*2/3)+1);
2778 ON_CALL(*g_stateAction, GetDisplayState())
2779 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2780 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2781 .Times(::testing::AtLeast(1))
2782 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2783 sleep(time/1000*1/3+1);
2784 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
2785 .Times(1)
2786 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2787 ON_CALL(*g_stateAction, GetDisplayState())
2788 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2789 sleep(SLEEP_WAIT_TIME_S+1);
2790
2791 ResetMockAction();
2792 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
2793 GTEST_LOG_(INFO) << "PowerMgrUnittest082: end.";
2794 }
2795
2796 /**
2797 * @tc.name: PowerMgrUnittest083
2798 * @tc.desc: test Auto SuspendDevice by mock after 2mins
2799 * @tc.type: FUNC
2800 */
2801 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest083, TestSize.Level2)
2802 {
2803 int64_t time =120000;
2804 sleep(NEXT_WAIT_TIME_S);
2805 GTEST_LOG_(INFO) << "PowerMgrUnittest083: start.";
2806
2807 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2808 if (pms == nullptr) {
2809 GTEST_LOG_(INFO) << "PowerMgrUnittest083: Failed to get PowerMgrService";
2810 }
2811
2812 pms->SetDisplayOffTime(time);
2813 ON_CALL(*g_stateAction, GetDisplayState())
2814 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2815 sleep(((time/1000)*2/3)+1);
2816 ON_CALL(*g_stateAction, GetDisplayState())
2817 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2818 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2819 .Times(::testing::AtLeast(1))
2820 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2821 sleep(time/1000*1/3+1);
2822 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
2823 .Times(1)
2824 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2825 ON_CALL(*g_stateAction, GetDisplayState())
2826 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2827 sleep(SLEEP_WAIT_TIME_S+1);
2828
2829 ResetMockAction();
2830 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
2831 GTEST_LOG_(INFO) << "PowerMgrUnittest083: end.";
2832 }
2833
2834 /**
2835 * @tc.name: PowerMgrUnittest084
2836 * @tc.desc: test Auto SuspendDevice by mock after 5mins
2837 * @tc.type: FUNC
2838 */
2839 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest084, TestSize.Level2)
2840 {
2841 int64_t time =300000;
2842 sleep(NEXT_WAIT_TIME_S);
2843 GTEST_LOG_(INFO) << "PowerMgrUnittest084: start.";
2844
2845 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2846 if (pms == nullptr) {
2847 GTEST_LOG_(INFO) << "PowerMgrUnittest084: Failed to get PowerMgrService";
2848 }
2849
2850 pms->SetDisplayOffTime(time);
2851 ON_CALL(*g_stateAction, GetDisplayState())
2852 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2853 sleep(((time/1000)*2/3)+1);
2854 ON_CALL(*g_stateAction, GetDisplayState())
2855 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2856 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2857 .Times(::testing::AtLeast(1))
2858 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2859 sleep(time/1000*1/3+1);
2860 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
2861 .Times(1)
2862 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2863 ON_CALL(*g_stateAction, GetDisplayState())
2864 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2865 sleep(SLEEP_WAIT_TIME_S+1);
2866
2867 ResetMockAction();
2868 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
2869 GTEST_LOG_(INFO) << "PowerMgrUnittest084: end.";
2870 }
2871
2872 /**
2873 * @tc.name: PowerMgrUnittest085
2874 * @tc.desc: test Auto SuspendDevice by mock after 10mins
2875 * @tc.type: FUNC
2876 */
2877 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest085, TestSize.Level2)
2878 {
2879 int64_t time =600000;
2880 sleep(NEXT_WAIT_TIME_S);
2881 GTEST_LOG_(INFO) << "PowerMgrUnittest085: start.";
2882
2883 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2884 if (pms == nullptr) {
2885 GTEST_LOG_(INFO) << "PowerMgrUnittest085: Failed to get PowerMgrService";
2886 }
2887
2888 pms->SetDisplayOffTime(time);
2889 ON_CALL(*g_stateAction, GetDisplayState())
2890 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2891 sleep(((time/1000)*2/3)+1);
2892 ON_CALL(*g_stateAction, GetDisplayState())
2893 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2894 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2895 .Times(::testing::AtLeast(1))
2896 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2897 sleep(time/1000*1/3+1);
2898 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false))
2899 .Times(1)
2900 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2901 ON_CALL(*g_stateAction, GetDisplayState())
2902 .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
2903 sleep(SLEEP_WAIT_TIME_S+1);
2904
2905 ResetMockAction();
2906 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
2907 GTEST_LOG_(INFO) << "PowerMgrUnittest085: end.";
2908 }
2909
2910 /**
2911 * @tc.name: PowerMgrUnittest086
2912 * @tc.desc: test Auto DIM by mock after 15s
2913 * @tc.type: FUNC
2914 */
2915 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest086, TestSize.Level2)
2916 {
2917 int64_t time =15000;
2918 sleep(NEXT_WAIT_TIME_S);
2919 GTEST_LOG_(INFO) << "PowerMgrUnittest086: start.";
2920 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest086:Start.");
2921
2922 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2923 if (pms == nullptr) {
2924 GTEST_LOG_(INFO) << "PowerMgrUnittest086: Failed to get PowerMgrService";
2925 }
2926 pms->SetDisplayOffTime(time);
2927 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
2928 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest086:DeviceStateAction::SetDisplayState.");
2929 ON_CALL(*g_stateAction, GetDisplayState())
2930 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2931 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_))
2932 .Times(1)
2933 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2934 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2935 .Times(1)
2936 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2937 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest086:Start sleep.");
2938 sleep(time/1000-2);
2939 ON_CALL(*g_stateAction, GetDisplayState())
2940 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2941 sleep(3);
2942 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest086: sleep end.");
2943
2944 ResetMockAction();
2945 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest086:End.");
2946 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
2947 GTEST_LOG_(INFO) << "PowerMgrUnittest086: end.";
2948 }
2949
2950 /**
2951 * @tc.name: PowerMgrUnittest087
2952 * @tc.desc: test Auto DIM by mock after 30s
2953 * @tc.type: FUNC
2954 */
2955 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest087, TestSize.Level2)
2956 {
2957 int64_t time =30000;
2958 sleep(NEXT_WAIT_TIME_S);
2959 GTEST_LOG_(INFO) << "PowerMgrUnittest087: start.";
2960 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest0087:Start.");
2961
2962 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2963 if (pms == nullptr) {
2964 GTEST_LOG_(INFO) << "PowerMgrUnittest087: Failed to get PowerMgrService";
2965 }
2966 ON_CALL(*g_stateAction, GetDisplayState())
2967 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
2968 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_))
2969 .Times(1)
2970 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2971 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
2972 .Times(1)
2973 .WillOnce(::testing::Return(ActionResult::SUCCESS));
2974 pms->SetDisplayOffTime(time);
2975 sleep(time/1000-2);
2976 ON_CALL(*g_stateAction, GetDisplayState())
2977 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
2978 sleep(3);
2979
2980 ResetMockAction();
2981 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest087:End.");
2982 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
2983 GTEST_LOG_(INFO) << "PowerMgrUnittest087: end.";
2984 }
2985
2986 /**
2987 * @tc.name: PowerMgrUnittest088
2988 * @tc.desc: test Auto DIM by mock after 60s
2989 * @tc.type: FUNC
2990 */
2991 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest088, TestSize.Level2)
2992 {
2993 int64_t time =60000;
2994 sleep(NEXT_WAIT_TIME_S);
2995 GTEST_LOG_(INFO) << "PowerMgrUnittest088: start.";
2996
2997 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2998 if (pms == nullptr) {
2999 GTEST_LOG_(INFO) << "PowerMgrUnittest088: Failed to get PowerMgrService";
3000 }
3001 ON_CALL(*g_stateAction, GetDisplayState())
3002 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
3003 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_))
3004 .Times(1)
3005 .WillOnce(::testing::Return(ActionResult::SUCCESS));
3006 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
3007 .Times(1)
3008 .WillOnce(::testing::Return(ActionResult::SUCCESS));
3009 pms->SetDisplayOffTime(time);
3010 sleep(time/1000-2);
3011 ON_CALL(*g_stateAction, GetDisplayState())
3012 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
3013 sleep(3);
3014
3015 ResetMockAction();
3016 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
3017 GTEST_LOG_(INFO) << "PowerMgrUnittest088: end.";
3018 }
3019
3020 /**
3021 * @tc.name: PowerMgrUnittest089
3022 * @tc.desc: test Auto DIM by mock after 2min
3023 * @tc.type: FUNC
3024 */
3025 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest089, TestSize.Level2)
3026 {
3027 int64_t time =120000;
3028 sleep(NEXT_WAIT_TIME_S);
3029 GTEST_LOG_(INFO) << "PowerMgrUnittest089: start.";
3030
3031 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
3032 if (pms == nullptr) {
3033 GTEST_LOG_(INFO) << "PowerMgrUnittest089: Failed to get PowerMgrService";
3034 }
3035 ON_CALL(*g_stateAction, GetDisplayState())
3036 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
3037 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_))
3038 .Times(1)
3039 .WillOnce(::testing::Return(ActionResult::SUCCESS));
3040 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
3041 .Times(1)
3042 .WillOnce(::testing::Return(ActionResult::SUCCESS));
3043 pms->SetDisplayOffTime(time);
3044 sleep(time/1000-2);
3045 ON_CALL(*g_stateAction, GetDisplayState())
3046 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
3047 sleep(3);
3048
3049 ResetMockAction();
3050 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
3051 GTEST_LOG_(INFO) << "PowerMgrUnittest089: end.";
3052 }
3053
3054 /**
3055 * @tc.name: PowerMgrUnittest090
3056 * @tc.desc: test Auto DIM by mock after 5min
3057 * @tc.type: FUNC
3058 */
3059 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest090, TestSize.Level2)
3060 {
3061 int64_t time =300000;
3062 sleep(NEXT_WAIT_TIME_S);
3063 GTEST_LOG_(INFO) << "PowerMgrUnittest090: start.";
3064
3065 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
3066 if (pms == nullptr) {
3067 GTEST_LOG_(INFO) << "PowerMgrUnittest090: Failed to get PowerMgrService";
3068 }
3069 ON_CALL(*g_stateAction, GetDisplayState())
3070 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
3071 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_))
3072 .Times(1)
3073 .WillOnce(::testing::Return(ActionResult::SUCCESS));
3074 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
3075 .Times(1)
3076 .WillOnce(::testing::Return(ActionResult::SUCCESS));
3077 pms->SetDisplayOffTime(time);
3078 sleep(time/1000-2);
3079 ON_CALL(*g_stateAction, GetDisplayState())
3080 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
3081 sleep(3);
3082
3083 ResetMockAction();
3084 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
3085 GTEST_LOG_(INFO) << "PowerMgrUnittest090: end.";
3086 }
3087
3088 /**
3089 * @tc.name: PowerMgrUnittest091
3090 * @tc.desc: test proximity screen control RunningLock by mock
3091 * @tc.type: FUNC
3092 */
3093 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest091, TestSize.Level2)
3094 {
3095 sleep(NEXT_WAIT_TIME_S);
3096 GTEST_LOG_(INFO) << "PowerMgrUnittest091: start.";
3097 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest091:Start.");
3098
3099 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
3100 if (pms == nullptr) {
3101 GTEST_LOG_(INFO) << "PowerMgrUnittest091: Failed to get PowerMgrService";
3102 }
3103
3104 sptr<IRemoteObject> token = new RunningLockTokenStub();
3105 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
3106 pms->CreateRunningLock(token, info);
3107 pms->Lock(token, info, 0);
3108 EXPECT_EQ(pms->IsUsed(token), true);
3109 sleep(SLEEP_WAIT_TIME_S);
3110 pms->UnLock(token);
3111 EXPECT_EQ(pms->IsUsed(token), false);
3112 ON_CALL(*g_stateAction, GetDisplayState())
3113 .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
3114 sleep((SCREEN_OFF_WAIT_TIME_S*2/3)+1);
3115 ON_CALL(*g_stateAction, GetDisplayState())
3116 .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
3117 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
3118 .Times(::testing::AtLeast(1))
3119 .WillOnce(::testing::Return(ActionResult::SUCCESS));
3120 sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1);
3121 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
3122
3123 ResetMockAction();
3124 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest091:End.");
3125 GTEST_LOG_(INFO) << "PowerMgrUnittest091: end.";
3126 }
3127
3128 /**
3129 * @tc.name: PowerMgrUnittest092
3130 * @tc.desc: test RebootDeviceForDeprecated by mock
3131 * @tc.type: FUNC
3132 */
3133 HWTEST_F (PowerMgrMockTest, PowerMgrUnittest001, TestSize.Level2)
3134 {
3135 sleep(NEXT_WAIT_TIME_S);
3136 GTEST_LOG_(INFO) << "PowerMgrUnittest092: start.";
3137 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest092:Start.");
3138
3139 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
3140 EXPECT_CALL(*g_powerAction, Reboot(std::string("test"))).Times(1);
3141 pms->RebootDeviceForDeprecated(std::string("test"));
3142
3143 ResetMockAction();
3144 POWER_HILOGD(LABEL_TEST, "PowerMgrUnittest092:End.");
3145 GTEST_LOG_(INFO) << "PowerMgrUnittest092: end.";
3146 }
3147 }
3148