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_st_mock_test.h"
17 #include "power_mgr_client.h"
18
19 using namespace testing::ext;
20 using namespace OHOS::PowerMgr;
21 using namespace OHOS;
22 using namespace std;
23 using ::testing::_;
24
25 static sptr<PowerMgrService> g_service;
26 static MockStateAction* g_shutdownState;
27 static MockStateAction* g_stateAction;
28 static MockPowerAction* g_powerAction;
29 static MockLockAction* g_lockAction;
30
ResetMockAction()31 static void ResetMockAction()
32 {
33 POWER_HILOGD(LABEL_TEST, "ResetMockAction:Start");
34 g_stateAction = new MockStateAction();
35 g_shutdownState = new MockStateAction();
36 g_powerAction = new MockPowerAction();
37 g_lockAction = new MockLockAction();
38 g_service->EnableMock(g_stateAction, g_shutdownState, g_powerAction, g_lockAction);
39 }
40
SetUpTestCase(void)41 void PowerMgrSTMockTest::SetUpTestCase(void)
42 {
43 // create singleton service object at the beginning
44 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
45 g_service->OnStart();
46 ResetMockAction();
47 }
48
TearDownTestCase(void)49 void PowerMgrSTMockTest::TearDownTestCase(void)
50 {
51 g_service->OnStop();
52 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
53 }
54
SetUp(void)55 void PowerMgrSTMockTest::SetUp(void)
56 {
57 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
58 }
59
TearDown(void)60 void PowerMgrSTMockTest::TearDown(void)
61 {
62 ResetMockAction();
63 }
64
65 namespace {
66 constexpr int32_t TEST_TIMES = 1000;
67 /**
68 * @tc.name: PowerMgrMock001
69 * @tc.desc: test RebootDevice by mock
70 * @tc.type: FUNC
71 * @tc.require: issueI5MJZJ
72 */
73 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock001, TestSize.Level2)
74 {
75 GTEST_LOG_(INFO) << "PowerMgrMock001: start";
76 POWER_HILOGD(LABEL_TEST, "PowerMgrMock001:Start");
77
78 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
79 if (pms == nullptr) {
80 GTEST_LOG_(INFO) << "PowerMgrMock001: Failed to get PowerMgrService";
81 }
82
83 EXPECT_CALL(*g_powerAction, Reboot(std::string("test"))).Times(1);
84 pms->RebootDevice(std::string("test"));
85
86 POWER_HILOGD(LABEL_TEST, "PowerMgrMock001:End");
87 GTEST_LOG_(INFO) << "PowerMgrMock001: end";
88 usleep(SLEEP_WAIT_TIME_MS * TRANSFER_NS_TO_MS);
89 }
90
91 /**
92 * @tc.name: PowerMgrMock002
93 * @tc.desc: test ShutDownDevice by mock
94 * @tc.type: FUNC
95 * @tc.require: issueI5MJZJ
96 */
97 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock002, TestSize.Level2)
98 {
99 GTEST_LOG_(INFO) << "PowerMgrMock002: start";
100 POWER_HILOGI(LABEL_TEST, "PowerMgrMock002:Start");
101
102 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
103 if (pms == nullptr) {
104 GTEST_LOG_(INFO) << "PowerMgrMock002: Failed to get PowerMgrService";
105 }
106
107 EXPECT_CALL(*g_powerAction, Shutdown(std::string("test"))).Times(1);
108 pms->ShutDownDevice(std::string("test"));
109
110 POWER_HILOGI(LABEL_TEST, "PowerMgrMock002:End");
111 GTEST_LOG_(INFO) << "PowerMgrMock002: end";
112 usleep(SLEEP_WAIT_TIME_MS * TRANSFER_NS_TO_MS);
113 }
114
115 /**
116 * @tc.name: PowerMgrMock029
117 * @tc.desc: test ForceSuspendDevice by mock
118 * @tc.type: FUNC
119 * @tc.require: issueI5MJZJ
120 */
121 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock029, TestSize.Level2)
122 {
123 GTEST_LOG_(INFO) << "PowerMgrMock029: start";
124 POWER_HILOGI(LABEL_TEST, "PowerMgrMock029:Start");
125
126 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
127 if (pms == nullptr) {
128 GTEST_LOG_(INFO) << "PowerMgrMock029: Failed to get PowerMgrService";
129 }
130
131 POWER_HILOGI(LABEL_TEST, "PowerMgrMock029:forcesuspend");
132 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
133
134 POWER_HILOGI(LABEL_TEST, "PowerMgrMock029:End");
135 GTEST_LOG_(INFO) << "PowerMgrMock029: end";
136 }
137
138 /**
139 * @tc.name: PowerMgrMock030
140 * @tc.desc: test RunningLock by mock
141 * @tc.type: FUNC
142 * @tc.require: issueI5MJZJ
143 */
144 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock030, TestSize.Level2)
145 {
146 GTEST_LOG_(INFO) << "PowerMgrMock030: start";
147 POWER_HILOGD(LABEL_TEST, "PowerMgrMock030:Start");
148
149 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
150 if (pms == nullptr) {
151 GTEST_LOG_(INFO) << "PowerMgrMock030: Failed to get PowerMgrService";
152 }
153
154 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
155 sptr<IRemoteObject> token = new RunningLockTokenStub();
156 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
157 pms->CreateRunningLock(token, info);
158 pms->Lock(token, 0);
159 EXPECT_EQ(pms->IsUsed(token), true);
160 pms->UnLock(token);
161 EXPECT_EQ(pms->IsUsed(token), false);
162
163 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
164 POWER_HILOGD(LABEL_TEST, "PowerMgrMock030:End");
165 GTEST_LOG_(INFO) << "PowerMgrMock030: end";
166 }
167
168 /**
169 * @tc.name: PowerMgrMock032
170 * @tc.desc: test proximity RunningLock by mock
171 * @tc.type: FUNC
172 * @tc.require: issueI5MJZJ
173 */
174 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock032, TestSize.Level2)
175 {
176 GTEST_LOG_(INFO) << "PowerMgrMock032: start";
177 POWER_HILOGD(LABEL_TEST, "PowerMgrMock032:Start");
178
179 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
180 if (pms == nullptr) {
181 GTEST_LOG_(INFO) << "PowerMgrMock032: Failed to get PowerMgrService";
182 }
183
184 sptr<IRemoteObject> token = new RunningLockTokenStub();
185 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
186 pms->CreateRunningLock(token, info);
187
188 pms->Lock(token, 0);
189 EXPECT_EQ(pms->IsUsed(token), true);
190 sleep(SCREEN_DIM_WAIT_TIME_S + ONE_SECOND);
191
192 pms->UnLock(token);
193 EXPECT_EQ(pms->IsUsed(token), false);
194
195 POWER_HILOGD(LABEL_TEST, "PowerMgrMock032:End");
196 GTEST_LOG_(INFO) << "PowerMgrMock032: end";
197 }
198
199 /**
200 * @tc.name: PowerMgrMock054
201 * @tc.desc: test ForceSuspendDevice by mock during Inactive
202 * @tc.type: FUNC
203 * @tc.require: issueI5MJZJ
204 */
205 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock054, TestSize.Level2)
206 {
207 GTEST_LOG_(INFO) << "PowerMgrMock054: start";
208 POWER_HILOGD(LABEL_TEST, "PowerMgrMock054:Start");
209
210 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
211 if (pms == nullptr) {
212 GTEST_LOG_(INFO) << "PowerMgrMock054: Failed to get PowerMgrService";
213 }
214
215 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
216 pms->ForceSuspendDevice(0);
217 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
218
219 POWER_HILOGD(LABEL_TEST, "PowerMgrMock054:End");
220 GTEST_LOG_(INFO) << "PowerMgrMock054: end";
221 }
222
223 /**
224 * @tc.name: PowerMgrMock063
225 * @tc.desc: test Screen RunningLock by mock
226 * @tc.type: FUNC
227 * @tc.require: issueI5MJZJ
228 */
229 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock063, TestSize.Level2)
230 {
231 GTEST_LOG_(INFO) << "PowerMgrMock063: start";
232 POWER_HILOGD(LABEL_TEST, "PowerMgrMock063:Start");
233
234 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
235 if (pms == nullptr) {
236 GTEST_LOG_(INFO) << "PowerMgrMock063: Failed to get PowerMgrService";
237 }
238
239 sptr<IRemoteObject> token = new RunningLockTokenStub();
240 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
241 pms->CreateRunningLock(token, info);
242
243 pms->Lock(token, 0);
244 EXPECT_EQ(pms->IsUsed(token), true);
245
246 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
247 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
248
249 pms->UnLock(token);
250 EXPECT_EQ(pms->IsUsed(token), false);
251
252 POWER_HILOGD(LABEL_TEST, "PowerMgrMock063:End");
253 GTEST_LOG_(INFO) << "PowerMgrMock063: end";
254 }
255
256 /**
257 * @tc.name: PowerMgrMock071
258 * @tc.desc: test proximity screen control RunningLock by mock
259 * @tc.type: FUNC
260 * @tc.require: issueI5MJZJ
261 */
262 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock071, TestSize.Level2)
263 {
264 GTEST_LOG_(INFO) << "PowerMgrMock071: start";
265 POWER_HILOGD(LABEL_TEST, "PowerMgrMock071:Start");
266
267 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
268 if (pms == nullptr) {
269 GTEST_LOG_(INFO) << "PowerMgrMock071: Failed to get PowerMgrService";
270 }
271
272 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
273 sptr<IRemoteObject> token = new RunningLockTokenStub();
274 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
275 pms->CreateRunningLock(token, info);
276 EXPECT_CALL(*g_stateAction, GetDisplayState())
277 .Times(::testing::AtLeast(1))
278 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_ON));
279 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
280 .Times(::testing::AtLeast(1))
281 .WillOnce(::testing::Return(ActionResult::SUCCESS));
282 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
283 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
284 EXPECT_CALL(*g_stateAction, GetDisplayState())
285 .Times(::testing::AtLeast(1))
286 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
287 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
288 .Times(1)
289 .WillOnce(::testing::Return(ActionResult::SUCCESS));
290 sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND);
291 pms->Lock(token, 0);
292 EXPECT_EQ(pms->IsUsed(token), true);
293
294 pms->UnLock(token);
295 EXPECT_EQ(pms->IsUsed(token), false);
296
297 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
298 POWER_HILOGD(LABEL_TEST, "PowerMgrMock071:End");
299 GTEST_LOG_(INFO) << "PowerMgrMock071: end";
300 }
301
302 /**
303 * @tc.name: PowerMgrMock072
304 * @tc.desc: test proximity screen control RunningLock by mock
305 * @tc.type: FUNC
306 * @tc.require: issueI5MJZJ
307 */
308 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock072, TestSize.Level2)
309 {
310 GTEST_LOG_(INFO) << "PowerMgrMock072: start";
311 POWER_HILOGD(LABEL_TEST, "PowerMgrMock072:Start");
312
313 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
314 if (pms == nullptr) {
315 GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService";
316 }
317
318 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
319 sptr<IRemoteObject> token = new RunningLockTokenStub();
320 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
321 pms->CreateRunningLock(token, info);
322 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
323 EXPECT_CALL(*g_stateAction, GetDisplayState())
324 .Times(::testing::AtLeast(1))
325 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
326 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
327 .Times(1)
328 .WillOnce(::testing::Return(ActionResult::SUCCESS));
329 sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND);
330 pms->Lock(token, 0);
331 EXPECT_EQ(pms->IsUsed(token), true);
332 pms->UnLock(token);
333 EXPECT_EQ(pms->IsUsed(token), false);
334
335 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
336 POWER_HILOGD(LABEL_TEST, "PowerMgrMock072:End");
337 GTEST_LOG_(INFO) << "PowerMgrMock072: end";
338 }
339
340 /**
341 * @tc.name: PowerMgrMock074
342 * @tc.desc: test proximity RunningLock by mock
343 * @tc.type: FUNC
344 * @tc.require: issueI5MJZJ
345 */
346 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock074, TestSize.Level2)
347 {
348 GTEST_LOG_(INFO) << "PowerMgrMock074: start";
349 POWER_HILOGD(LABEL_TEST, "PowerMgrMock074:Start");
350
351 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
352 if (pms == nullptr) {
353 GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService";
354 }
355
356 sptr<IRemoteObject> token = new RunningLockTokenStub();
357 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
358 pms->CreateRunningLock(token, info);
359
360 pms->Lock(token, 0);
361 EXPECT_EQ(pms->IsUsed(token), true);
362 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
363
364 POWER_HILOGD(LABEL_TEST, "PowerMgrMock074:End");
365 GTEST_LOG_(INFO) << "PowerMgrMock074: end";
366 }
367
368 /**
369 * @tc.name: PowerMgrMock075
370 * @tc.desc: test proximity RunningLock by mock
371 * @tc.type: FUNC
372 * @tc.require: issueI5MJZJ
373 */
374 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock075, TestSize.Level2)
375 {
376 GTEST_LOG_(INFO) << "PowerMgrMock075: start";
377 POWER_HILOGD(LABEL_TEST, "PowerMgrMock075:Start");
378
379 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
380 if (pms == nullptr) {
381 GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService";
382 }
383
384 sptr<IRemoteObject> token = new RunningLockTokenStub();
385 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
386 pms->CreateRunningLock(token, info);
387 pms->Lock(token, 0);
388 EXPECT_EQ(pms->IsUsed(token), true);
389 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
390 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
391
392 POWER_HILOGD(LABEL_TEST, "PowerMgrMock075:End");
393 GTEST_LOG_(INFO) << "PowerMgrMock075: end";
394 }
395
396 /**
397 * @tc.name: PowerMgrMock076
398 * @tc.desc: test proximity RunningLock by mock
399 * @tc.type: FUNC
400 * @tc.require: issueI5MJZJ
401 */
402 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock076, TestSize.Level2)
403 {
404 int i;
405 GTEST_LOG_(INFO) << "PowerMgrMock076: start";
406 POWER_HILOGD(LABEL_TEST, "PowerMgrMock076:Start");
407
408 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
409 if (pms == nullptr) {
410 GTEST_LOG_(INFO) << "PowerMgrMock076: Failed to get PowerMgrService";
411 }
412
413 pms->SetDisplayOffTime(ASYNC_WAIT_TIME_S * TEST_TIMES);
414 sptr<IRemoteObject> token = new RunningLockTokenStub();
415 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
416 pms->CreateRunningLock(token, info);
417 for (i = 0; i < 10; i++) {
418 pms->Lock(token, 0);
419 EXPECT_EQ(pms->IsUsed(token), true);
420 pms->UnLock(token);
421 EXPECT_EQ(pms->IsUsed(token), false);
422 }
423 pms->Lock(token, 0);
424 EXPECT_EQ(pms->IsUsed(token), true);
425
426 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
427 POWER_HILOGD(LABEL_TEST, "PowerMgrMock076:End");
428 GTEST_LOG_(INFO) << "PowerMgrMock076: end";
429 }
430
431 /**
432 * @tc.name: PowerMgrMock078
433 * @tc.desc: test proximity RunningLock by mock
434 * @tc.type: FUNC
435 * @tc.require: issueI5MJZJ
436 */
437 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock078, TestSize.Level2)
438 {
439 GTEST_LOG_(INFO) << "PowerMgrMock078: start";
440 POWER_HILOGD(LABEL_TEST, "PowerMgrMock078:Start");
441
442 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
443 if (pms == nullptr) {
444 GTEST_LOG_(INFO) << "PowerMgrMock078: Failed to get PowerMgrService";
445 }
446
447 sptr<IRemoteObject> token = new RunningLockTokenStub();
448 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
449 pms->CreateRunningLock(token, info);
450 pms->Lock(token, 0);
451 EXPECT_EQ(pms->IsUsed(token), true);
452
453 pms->ForceSuspendDevice(0);
454
455 pms->UnLock(token);
456 EXPECT_EQ(pms->IsUsed(token), false);
457
458 POWER_HILOGD(LABEL_TEST, "PowerMgrMock078:End");
459 GTEST_LOG_(INFO) << "PowerMgrMock078: end";
460 }
461
462 /**
463 * @tc.name: PowerMgrMock079
464 * @tc.desc: test proximity RunningLock by mock
465 * @tc.type: FUNC
466 * @tc.require: issueI5MJZJ
467 */
468 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock079, TestSize.Level2)
469 {
470 GTEST_LOG_(INFO) << "PowerMgrMock079: start";
471 POWER_HILOGD(LABEL_TEST, "PowerMgrMock079:Start");
472
473 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
474 if (pms == nullptr) {
475 GTEST_LOG_(INFO) << "PowerMgrMock079: Failed to get PowerMgrService";
476 }
477
478 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
479 sptr<IRemoteObject> token = new RunningLockTokenStub();
480 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
481 pms->CreateRunningLock(token, info);
482
483 pms->Lock(token, 0);
484 EXPECT_EQ(pms->IsUsed(token), true);
485
486 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
487 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
488
489 POWER_HILOGD(LABEL_TEST, "PowerMgrMock079:End");
490 GTEST_LOG_(INFO) << "PowerMgrMock079: end";
491 }
492
493 /**
494 * @tc.name: PowerMgrMock081
495 * @tc.desc: test The display status and power status are inconsistent SuspendDevice
496 * @tc.type: FUNC
497 * @tc.require: issueI66HYP
498 */
499 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock081, TestSize.Level2)
500 {
501 GTEST_LOG_(INFO) << "PowerMgrMock081: start.";
502 POWER_HILOGD(LABEL_TEST, "PowerMgrMock081:Start.");
503
504 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
505 ASSERT_TRUE(pms != nullptr);
506
507 // Set the power status to INACTIVE
508 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
509 EXPECT_TRUE(pms->GetState() == PowerState::INACTIVE || pms->GetState() == PowerState::SLEEP);
510
511 // Analog display return DISPLAY_ON
512 EXPECT_CALL(*g_stateAction, GetDisplayState())
513 .Times(::testing::AtLeast(1))
514 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_ON));
515 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
516 .Times(::testing::AtLeast(1))
517 .WillOnce(::testing::Return(ActionResult::SUCCESS));
518 // The status is changed to display status ON, and the screen is off again
519 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
520 EXPECT_TRUE(pms->GetState() == PowerState::INACTIVE || pms->GetState() == PowerState::SLEEP);
521
522 POWER_HILOGD(LABEL_TEST, "PowerMgrMock081:End.");
523 GTEST_LOG_(INFO) << "PowerMgrMock081: end.";
524 }
525
526 /**
527 * @tc.name: PowerMgrMock082
528 * @tc.desc: test The display status and power status are inconsistent WakeupDevice
529 * @tc.type: FUNC
530 * @tc.require: issueI66HYP
531 */
532 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock082, TestSize.Level2)
533 {
534 GTEST_LOG_(INFO) << "PowerMgrMock082: start.";
535 POWER_HILOGD(LABEL_TEST, "PowerMgrMock082:Start.");
536
537 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
538 ASSERT_TRUE(pms != nullptr);
539
540 // Set the power status to AWAKE
541 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("PowerMgrMock082"));
542 EXPECT_TRUE(pms->GetState() == PowerState::AWAKE);
543
544 // Analog display return DISPLAY_OFF
545 EXPECT_CALL(*g_stateAction, GetDisplayState())
546 .Times(::testing::AtLeast(1))
547 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
548 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
549 .Times(::testing::AtLeast(1))
550 .WillOnce(::testing::Return(ActionResult::SUCCESS));
551 // The status is changed to display status OFF, and the screen is off again
552 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("PowerMgrMock082_Again"));
553 EXPECT_TRUE(pms->GetState() == PowerState::AWAKE);
554
555 POWER_HILOGD(LABEL_TEST, "PowerMgrMock082:End.");
556 GTEST_LOG_(INFO) << "PowerMgrMock082: end.";
557 }
558 } // namespace
559