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 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
132 POWER_HILOGI(LABEL_TEST, "PowerMgrMock029:forcesuspend");
133 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
134
135 POWER_HILOGI(LABEL_TEST, "PowerMgrMock029:End");
136 GTEST_LOG_(INFO) << "PowerMgrMock029: end";
137 }
138
139 /**
140 * @tc.name: PowerMgrMock030
141 * @tc.desc: test RunningLock by mock
142 * @tc.type: FUNC
143 * @tc.require: issueI5MJZJ
144 */
145 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock030, TestSize.Level2)
146 {
147 GTEST_LOG_(INFO) << "PowerMgrMock030: start";
148 POWER_HILOGD(LABEL_TEST, "PowerMgrMock030:Start");
149
150 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
151 if (pms == nullptr) {
152 GTEST_LOG_(INFO) << "PowerMgrMock030: Failed to get PowerMgrService";
153 }
154
155 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
156 sptr<IRemoteObject> token = new RunningLockTokenStub();
157 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
158 pms->CreateRunningLock(token, info);
159 pms->Lock(token, 0);
160 EXPECT_EQ(pms->IsUsed(token), true);
161 pms->UnLock(token);
162 EXPECT_EQ(pms->IsUsed(token), false);
163
164 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
165 POWER_HILOGD(LABEL_TEST, "PowerMgrMock030:End");
166 GTEST_LOG_(INFO) << "PowerMgrMock030: end";
167 }
168
169 /**
170 * @tc.name: PowerMgrMock032
171 * @tc.desc: test proximity RunningLock by mock
172 * @tc.type: FUNC
173 * @tc.require: issueI5MJZJ
174 */
175 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock032, TestSize.Level2)
176 {
177 GTEST_LOG_(INFO) << "PowerMgrMock032: start";
178 POWER_HILOGD(LABEL_TEST, "PowerMgrMock032:Start");
179
180 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
181 if (pms == nullptr) {
182 GTEST_LOG_(INFO) << "PowerMgrMock032: Failed to get PowerMgrService";
183 }
184
185 EXPECT_CALL(*g_stateAction, GetDisplayState())
186 .Times(::testing::AtLeast(1))
187 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
188 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
189 .Times(::testing::AtLeast(1))
190 .WillOnce(::testing::Return(ActionResult::SUCCESS));
191 sptr<IRemoteObject> token = new RunningLockTokenStub();
192 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
193 pms->CreateRunningLock(token, info);
194
195 EXPECT_CALL(*g_lockAction, Lock(_)).Times(1);
196 pms->Lock(token, 0);
197 EXPECT_EQ(pms->IsUsed(token), true);
198 EXPECT_CALL(*g_stateAction, GetDisplayState())
199 .Times(::testing::AtLeast(1))
200 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
201 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
202 .Times(::testing::AtLeast(1))
203 .WillOnce(::testing::Return(ActionResult::SUCCESS));
204 sleep(SCREEN_DIM_WAIT_TIME_S + ONE_SECOND);
205
206 EXPECT_CALL(*g_lockAction, Unlock(_)).Times(1);
207 pms->UnLock(token);
208 EXPECT_EQ(pms->IsUsed(token), false);
209
210 POWER_HILOGD(LABEL_TEST, "PowerMgrMock032:End");
211 GTEST_LOG_(INFO) << "PowerMgrMock032: end";
212 }
213
214 /**
215 * @tc.name: PowerMgrMock054
216 * @tc.desc: test ForceSuspendDevice by mock during Inactive
217 * @tc.type: FUNC
218 * @tc.require: issueI5MJZJ
219 */
220 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock054, TestSize.Level2)
221 {
222 GTEST_LOG_(INFO) << "PowerMgrMock054: start";
223 POWER_HILOGD(LABEL_TEST, "PowerMgrMock054:Start");
224
225 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
226 if (pms == nullptr) {
227 GTEST_LOG_(INFO) << "PowerMgrMock054: Failed to get PowerMgrService";
228 }
229
230 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
231 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _))
232 .Times(::testing::AtLeast(1))
233 .WillOnce(::testing::Return(ActionResult::SUCCESS));
234 pms->ForceSuspendDevice(0);
235 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
236 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
237
238 POWER_HILOGD(LABEL_TEST, "PowerMgrMock054:End");
239 GTEST_LOG_(INFO) << "PowerMgrMock054: end";
240 }
241
242 /**
243 * @tc.name: PowerMgrMock063
244 * @tc.desc: test Screen RunningLock by mock
245 * @tc.type: FUNC
246 * @tc.require: issueI5MJZJ
247 */
248 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock063, TestSize.Level2)
249 {
250 GTEST_LOG_(INFO) << "PowerMgrMock063: start";
251 POWER_HILOGD(LABEL_TEST, "PowerMgrMock063:Start");
252
253 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
254 if (pms == nullptr) {
255 GTEST_LOG_(INFO) << "PowerMgrMock063: Failed to get PowerMgrService";
256 }
257
258 sptr<IRemoteObject> token = new RunningLockTokenStub();
259 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
260 pms->CreateRunningLock(token, info);
261
262 pms->Lock(token, 0);
263 EXPECT_EQ(pms->IsUsed(token), true);
264
265 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
266 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
267 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
268
269 pms->UnLock(token);
270 EXPECT_EQ(pms->IsUsed(token), false);
271 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
272
273 POWER_HILOGD(LABEL_TEST, "PowerMgrMock063:End");
274 GTEST_LOG_(INFO) << "PowerMgrMock063: end";
275 }
276
277 /**
278 * @tc.name: PowerMgrMock071
279 * @tc.desc: test proximity screen control RunningLock by mock
280 * @tc.type: FUNC
281 * @tc.require: issueI5MJZJ
282 */
283 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock071, TestSize.Level2)
284 {
285 GTEST_LOG_(INFO) << "PowerMgrMock071: start";
286 POWER_HILOGD(LABEL_TEST, "PowerMgrMock071:Start");
287
288 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
289 if (pms == nullptr) {
290 GTEST_LOG_(INFO) << "PowerMgrMock071: Failed to get PowerMgrService";
291 }
292
293 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
294 sptr<IRemoteObject> token = new RunningLockTokenStub();
295 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
296 pms->CreateRunningLock(token, info);
297 EXPECT_CALL(*g_stateAction, GetDisplayState())
298 .Times(::testing::AtLeast(1))
299 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_ON));
300 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
301 .Times(::testing::AtLeast(1))
302 .WillOnce(::testing::Return(ActionResult::SUCCESS));
303 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
304 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
305 EXPECT_CALL(*g_stateAction, GetDisplayState())
306 .Times(::testing::AtLeast(1))
307 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
308 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
309 .Times(2)
310 .WillOnce(::testing::Return(ActionResult::SUCCESS));
311 sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND);
312 pms->Lock(token, 0);
313 EXPECT_EQ(pms->IsUsed(token), true);
314 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
315
316 pms->UnLock(token);
317 EXPECT_EQ(pms->IsUsed(token), false);
318
319 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
320 POWER_HILOGD(LABEL_TEST, "PowerMgrMock071:End");
321 GTEST_LOG_(INFO) << "PowerMgrMock071: end";
322 }
323
324 /**
325 * @tc.name: PowerMgrMock072
326 * @tc.desc: test proximity screen control RunningLock by mock
327 * @tc.type: FUNC
328 * @tc.require: issueI5MJZJ
329 */
330 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock072, TestSize.Level2)
331 {
332 GTEST_LOG_(INFO) << "PowerMgrMock072: start";
333 POWER_HILOGD(LABEL_TEST, "PowerMgrMock072:Start");
334
335 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
336 if (pms == nullptr) {
337 GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService";
338 }
339
340 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
341 sptr<IRemoteObject> token = new RunningLockTokenStub();
342 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
343 pms->CreateRunningLock(token, info);
344 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
345 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
346 EXPECT_CALL(*g_stateAction, GetDisplayState())
347 .Times(::testing::AtLeast(1))
348 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
349 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
350 .Times(2)
351 .WillOnce(::testing::Return(ActionResult::SUCCESS));
352 sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND);
353 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
354 pms->Lock(token, 0);
355 EXPECT_EQ(pms->IsUsed(token), true);
356 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
357 pms->UnLock(token);
358 EXPECT_EQ(pms->IsUsed(token), false);
359
360 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
361 POWER_HILOGD(LABEL_TEST, "PowerMgrMock072:End");
362 GTEST_LOG_(INFO) << "PowerMgrMock072: end";
363 }
364
365 /**
366 * @tc.name: PowerMgrMock074
367 * @tc.desc: test proximity RunningLock by mock
368 * @tc.type: FUNC
369 * @tc.require: issueI5MJZJ
370 */
371 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock074, TestSize.Level2)
372 {
373 GTEST_LOG_(INFO) << "PowerMgrMock074: start";
374 POWER_HILOGD(LABEL_TEST, "PowerMgrMock074:Start");
375
376 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
377 if (pms == nullptr) {
378 GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService";
379 }
380
381 sptr<IRemoteObject> token = new RunningLockTokenStub();
382 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
383 pms->CreateRunningLock(token, info);
384
385 EXPECT_CALL(*g_lockAction, Lock(_)).Times(1);
386 pms->Lock(token, 0);
387 EXPECT_EQ(pms->IsUsed(token), true);
388 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
389
390 POWER_HILOGD(LABEL_TEST, "PowerMgrMock074:End");
391 GTEST_LOG_(INFO) << "PowerMgrMock074: end";
392 }
393
394 /**
395 * @tc.name: PowerMgrMock075
396 * @tc.desc: test proximity RunningLock by mock
397 * @tc.type: FUNC
398 * @tc.require: issueI5MJZJ
399 */
400 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock075, TestSize.Level2)
401 {
402 GTEST_LOG_(INFO) << "PowerMgrMock075: start";
403 POWER_HILOGD(LABEL_TEST, "PowerMgrMock075:Start");
404
405 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
406 if (pms == nullptr) {
407 GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService";
408 }
409
410 sptr<IRemoteObject> token = new RunningLockTokenStub();
411 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
412 pms->CreateRunningLock(token, info);
413 pms->Lock(token, 0);
414 EXPECT_EQ(pms->IsUsed(token), true);
415 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
416 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
417
418 POWER_HILOGD(LABEL_TEST, "PowerMgrMock075:End");
419 GTEST_LOG_(INFO) << "PowerMgrMock075: end";
420 }
421
422 /**
423 * @tc.name: PowerMgrMock076
424 * @tc.desc: test proximity RunningLock by mock
425 * @tc.type: FUNC
426 * @tc.require: issueI5MJZJ
427 */
428 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock076, TestSize.Level2)
429 {
430 int i;
431 GTEST_LOG_(INFO) << "PowerMgrMock076: start";
432 POWER_HILOGD(LABEL_TEST, "PowerMgrMock076:Start");
433
434 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
435 if (pms == nullptr) {
436 GTEST_LOG_(INFO) << "PowerMgrMock076: Failed to get PowerMgrService";
437 }
438
439 pms->SetDisplayOffTime(ASYNC_WAIT_TIME_S * TEST_TIMES);
440 sptr<IRemoteObject> token = new RunningLockTokenStub();
441 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
442 pms->CreateRunningLock(token, info);
443 for (i = 0; i < 10; i++) {
444 pms->Lock(token, 0);
445 EXPECT_EQ(pms->IsUsed(token), true);
446 pms->UnLock(token);
447 EXPECT_EQ(pms->IsUsed(token), false);
448 }
449 pms->Lock(token, 0);
450 EXPECT_EQ(pms->IsUsed(token), true);
451 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
452 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
453
454 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
455 POWER_HILOGD(LABEL_TEST, "PowerMgrMock076:End");
456 GTEST_LOG_(INFO) << "PowerMgrMock076: end";
457 }
458
459 /**
460 * @tc.name: PowerMgrMock078
461 * @tc.desc: test proximity RunningLock by mock
462 * @tc.type: FUNC
463 * @tc.require: issueI5MJZJ
464 */
465 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock078, TestSize.Level2)
466 {
467 GTEST_LOG_(INFO) << "PowerMgrMock078: start";
468 POWER_HILOGD(LABEL_TEST, "PowerMgrMock078:Start");
469
470 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
471 if (pms == nullptr) {
472 GTEST_LOG_(INFO) << "PowerMgrMock078: Failed to get PowerMgrService";
473 }
474
475 sptr<IRemoteObject> token = new RunningLockTokenStub();
476 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
477 pms->CreateRunningLock(token, info);
478 EXPECT_CALL(*g_lockAction, Lock(_)).Times(1);
479 pms->Lock(token, 0);
480 EXPECT_EQ(pms->IsUsed(token), true);
481
482 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
483 pms->ForceSuspendDevice(0);
484 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
485
486 EXPECT_CALL(*g_lockAction, Unlock(_)).Times(1);
487 pms->UnLock(token);
488 EXPECT_EQ(pms->IsUsed(token), false);
489
490 POWER_HILOGD(LABEL_TEST, "PowerMgrMock078:End");
491 GTEST_LOG_(INFO) << "PowerMgrMock078: end";
492 }
493
494 /**
495 * @tc.name: PowerMgrMock079
496 * @tc.desc: test proximity RunningLock by mock
497 * @tc.type: FUNC
498 * @tc.require: issueI5MJZJ
499 */
500 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock079, TestSize.Level2)
501 {
502 GTEST_LOG_(INFO) << "PowerMgrMock079: start";
503 POWER_HILOGD(LABEL_TEST, "PowerMgrMock079:Start");
504
505 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
506 if (pms == nullptr) {
507 GTEST_LOG_(INFO) << "PowerMgrMock079: Failed to get PowerMgrService";
508 }
509
510 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
511 sptr<IRemoteObject> token = new RunningLockTokenStub();
512 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
513 pms->CreateRunningLock(token, info);
514
515 EXPECT_CALL(*g_lockAction, Lock(_)).Times(1);
516 pms->Lock(token, 0);
517 EXPECT_EQ(pms->IsUsed(token), true);
518
519 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
520 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
521
522 POWER_HILOGD(LABEL_TEST, "PowerMgrMock079:End");
523 GTEST_LOG_(INFO) << "PowerMgrMock079: end";
524 }
525
526 /**
527 * @tc.name: PowerMgrMock081
528 * @tc.desc: test The display status and power status are inconsistent SuspendDevice
529 * @tc.type: FUNC
530 * @tc.require: issueI66HYP
531 */
532 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock081, TestSize.Level2)
533 {
534 GTEST_LOG_(INFO) << "PowerMgrMock081: start.";
535 POWER_HILOGD(LABEL_TEST, "PowerMgrMock081:Start.");
536
537 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
538 ASSERT_TRUE(pms != nullptr);
539
540 // Set the power status to INACTIVE
541 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
542 EXPECT_TRUE(pms->GetState() == PowerState::INACTIVE || pms->GetState() == PowerState::SLEEP);
543
544 // Analog display return DISPLAY_ON
545 EXPECT_CALL(*g_stateAction, GetDisplayState())
546 .Times(::testing::AtLeast(1))
547 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_ON));
548 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
549 .Times(::testing::AtLeast(1))
550 .WillOnce(::testing::Return(ActionResult::SUCCESS));
551 // The status is changed to display status ON, and the screen is off again
552 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
553 EXPECT_TRUE(pms->GetState() == PowerState::INACTIVE || pms->GetState() == PowerState::SLEEP);
554
555 POWER_HILOGD(LABEL_TEST, "PowerMgrMock081:End.");
556 GTEST_LOG_(INFO) << "PowerMgrMock081: end.";
557 }
558
559 /**
560 * @tc.name: PowerMgrMock082
561 * @tc.desc: test The display status and power status are inconsistent WakeupDevice
562 * @tc.type: FUNC
563 * @tc.require: issueI66HYP
564 */
565 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock082, TestSize.Level2)
566 {
567 GTEST_LOG_(INFO) << "PowerMgrMock082: start.";
568 POWER_HILOGD(LABEL_TEST, "PowerMgrMock082:Start.");
569
570 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
571 ASSERT_TRUE(pms != nullptr);
572
573 // Set the power status to AWAKE
574 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("PowerMgrMock082"));
575 EXPECT_TRUE(pms->GetState() == PowerState::AWAKE);
576
577 // Analog display return DISPLAY_OFF
578 EXPECT_CALL(*g_stateAction, GetDisplayState())
579 .Times(::testing::AtLeast(1))
580 .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
581 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
582 .Times(::testing::AtLeast(1))
583 .WillOnce(::testing::Return(ActionResult::SUCCESS));
584 // The status is changed to display status OFF, and the screen is off again
585 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("PowerMgrMock082_Again"));
586 EXPECT_TRUE(pms->GetState() == PowerState::AWAKE);
587
588 POWER_HILOGD(LABEL_TEST, "PowerMgrMock082:End.");
589 GTEST_LOG_(INFO) << "PowerMgrMock082: end.";
590 }
591 } // namespace
592