1 /*
2 * Copyright (c) 2021 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 }
47
TearDownTestCase(void)48 void PowerMgrSTMockTest::TearDownTestCase(void)
49 {
50 g_service->OnStop();
51 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
52 }
53
SetUp(void)54 void PowerMgrSTMockTest::SetUp(void)
55 {
56 ResetMockAction();
57 }
58
TearDown(void)59 void PowerMgrSTMockTest::TearDown(void)
60 {
61 }
62
63 namespace {
64 /**
65 * @tc.name: PowerMgrMock001
66 * @tc.desc: test RebootDevice by mock
67 * @tc.type: FUNC
68 * @tc.require: issueI5MJZJ
69 */
70 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock001, TestSize.Level2)
71 {
72 GTEST_LOG_(INFO) << "PowerMgrMock001: start.";
73 POWER_HILOGD(LABEL_TEST, "PowerMgrMock001:Start.");
74
75 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
76 if (pms == nullptr) {
77 GTEST_LOG_(INFO) << "PowerMgrMock001: Failed to get PowerMgrService";
78 }
79
80 EXPECT_CALL(*g_powerAction, Reboot(std::string("test"))).Times(1);
81 pms->RebootDevice(std::string("test"));
82
83 POWER_HILOGD(LABEL_TEST, "PowerMgrMock001:End.");
84 GTEST_LOG_(INFO) << "PowerMgrMock001: end.";
85 usleep(SLEEP_WAIT_TIME_MS * TRANSFER_NS_TO_MS);
86 }
87
88 /**
89 * @tc.name: PowerMgrMock002
90 * @tc.desc: test ShutDownDevice by mock
91 * @tc.type: FUNC
92 * @tc.require: issueI5MJZJ
93 */
94 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock002, TestSize.Level2)
95 {
96 GTEST_LOG_(INFO) << "PowerMgrMock002: start.";
97 POWER_HILOGI(LABEL_TEST, "PowerMgrMock002:Start.");
98
99 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
100 if (pms == nullptr) {
101 GTEST_LOG_(INFO) << "PowerMgrMock002: Failed to get PowerMgrService";
102 }
103
104 EXPECT_CALL(*g_powerAction, Shutdown(std::string("test"))).Times(1);
105 pms->ShutDownDevice(std::string("test"));
106
107 POWER_HILOGI(LABEL_TEST, "PowerMgrMock002:End.");
108 GTEST_LOG_(INFO) << "PowerMgrMock002: end.";
109 usleep(SLEEP_WAIT_TIME_MS * TRANSFER_NS_TO_MS);
110 }
111
112 /**
113 * @tc.name: PowerMgrMock029
114 * @tc.desc: test ForceSuspendDevice by mock
115 * @tc.type: FUNC
116 * @tc.require: issueI5MJZJ
117 */
118 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock029, TestSize.Level2)
119 {
120 GTEST_LOG_(INFO) << "PowerMgrMock029: start.";
121 POWER_HILOGI(LABEL_TEST, "PowerMgrMock029:Start.");
122
123 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
124 if (pms == nullptr) {
125 GTEST_LOG_(INFO) << "PowerMgrMock029: Failed to get PowerMgrService";
126 }
127
128 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
129 POWER_HILOGI(LABEL_TEST, "PowerMgrMock029:forcesuspend.");
130 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
131
132 POWER_HILOGI(LABEL_TEST, "PowerMgrMock029:End.");
133 GTEST_LOG_(INFO) << "PowerMgrMock029: end.";
134 }
135
136 /**
137 * @tc.name: PowerMgrMock030
138 * @tc.desc: test Screen on RunningLock by mock
139 * @tc.type: FUNC
140 * @tc.require: issueI5MJZJ
141 */
142 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock030, TestSize.Level2)
143 {
144 GTEST_LOG_(INFO) << "PowerMgrMock030: start.";
145 POWER_HILOGD(LABEL_TEST, "PowerMgrMock030:Start.");
146
147 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
148 if (pms == nullptr) {
149 GTEST_LOG_(INFO) << "PowerMgrMock030: Failed to get PowerMgrService";
150 }
151
152 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
153 sptr<IRemoteObject> token = new RunningLockTokenStub();
154 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
155 pms->CreateRunningLock(token, info);
156 pms->Lock(token, info, 0);
157 EXPECT_EQ(pms->IsUsed(token), true);
158
159 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
160 sleep((REFRESHACTIVITY_WAIT_TIME_S / TEST_RATE) + 1);
161
162 pms->UnLock(token);
163 EXPECT_EQ(pms->IsUsed(token), false);
164
165 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
166 POWER_HILOGD(LABEL_TEST, "PowerMgrMock030:End.");
167 GTEST_LOG_(INFO) << "PowerMgrMock030: end.";
168 }
169
170 /**
171 * @tc.name: PowerMgrMock031
172 * @tc.desc: test background RunningLock by mock
173 * @tc.type: FUNC
174 * @tc.require: issueI5MJZJ
175 */
176 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock031, TestSize.Level2)
177 {
178 GTEST_LOG_(INFO) << "PowerMgrMock031: start.";
179 POWER_HILOGD(LABEL_TEST, "PowerMgrMock031:Start.");
180
181 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
182 if (pms == nullptr) {
183 GTEST_LOG_(INFO) << "PowerMgrMock031: Failed to get PowerMgrService";
184 }
185
186 sptr<IRemoteObject> token = new RunningLockTokenStub();
187 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
188 pms->CreateRunningLock(token, info);
189
190 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
191 pms->Lock(token, info, 0);
192 EXPECT_EQ(pms->IsUsed(token), true);
193
194 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
195 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
196 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
197
198 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
199 pms->UnLock(token);
200 EXPECT_EQ(pms->IsUsed(token), false);
201
202 POWER_HILOGD(LABEL_TEST, "PowerMgrMock031:End.");
203 GTEST_LOG_(INFO) << "PowerMgrMock031: end.";
204 }
205
206 /**
207 * @tc.name: PowerMgrMock032
208 * @tc.desc: test proximity RunningLock by mock
209 * @tc.type: FUNC
210 * @tc.require: issueI5MJZJ
211 */
212 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock032, TestSize.Level2)
213 {
214 GTEST_LOG_(INFO) << "PowerMgrMock032: start.";
215 POWER_HILOGD(LABEL_TEST, "PowerMgrMock032:Start.");
216
217 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
218 if (pms == nullptr) {
219 GTEST_LOG_(INFO) << "PowerMgrMock032: Failed to get PowerMgrService";
220 }
221
222 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
223 sptr<IRemoteObject> token = new RunningLockTokenStub();
224 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
225 pms->CreateRunningLock(token, info);
226
227 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
228 pms->Lock(token, info, 0);
229 EXPECT_EQ(pms->IsUsed(token), true);
230
231 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_DIM, ::testing::_)).Times(0);
232 sleep(SCREEN_DIM_WAIT_TIME_S + ONE_SECOND);
233
234 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
235 pms->UnLock(token);
236 EXPECT_EQ(pms->IsUsed(token), false);
237
238 POWER_HILOGD(LABEL_TEST, "PowerMgrMock032:End.");
239 GTEST_LOG_(INFO) << "PowerMgrMock032: end.";
240 }
241
242 /**
243 * @tc.name: PowerMgrMock033
244 * @tc.desc: test RunningLock release by mock
245 * @tc.type: FUNC
246 * @tc.require: issueI5MJZJ
247 */
248 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock033, TestSize.Level2)
249 {
250 GTEST_LOG_(INFO) << "PowerMgrMock033: start.";
251 POWER_HILOGD(LABEL_TEST, "PowerMgrMock033:Start.");
252
253 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
254 if (pms == nullptr) {
255 GTEST_LOG_(INFO) << "PowerMgrMock033: Failed to get PowerMgrService";
256 }
257
258 sptr<IRemoteObject> token = new RunningLockTokenStub();
259 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
260 pms->CreateRunningLock(token, info);
261 pms->ReleaseRunningLock(token);
262
263 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(0);
264 pms->Lock(token, info, 0);
265 EXPECT_EQ(pms->IsUsed(token), false);
266
267 POWER_HILOGD(LABEL_TEST, "PowerMgrMock033:End.");
268 GTEST_LOG_(INFO) << "PowerMgrMock033: end.";
269 }
270
271 /**
272 * @tc.name: PowerMgrMock048
273 * @tc.desc: test SuspendDevice by mock
274 * @tc.type: FUNC
275 * @tc.require: issueI5MJZJ
276 */
277 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock048, TestSize.Level2)
278 {
279 GTEST_LOG_(INFO) << "PowerMgrMock048: start.";
280 POWER_HILOGD(LABEL_TEST, "PowerMgrMock048:Start.");
281
282 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
283 if (pms == nullptr) {
284 GTEST_LOG_(INFO) << "PowerMgrMock048: Failed to get PowerMgrService";
285 }
286
287 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("test"));
288 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
289 .Times(::testing::AtLeast(1))
290 .WillOnce(::testing::Return(ActionResult::SUCCESS));
291 EXPECT_CALL(*g_stateAction, Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false));
292 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
293 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
294 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
295 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
296 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
297
298 POWER_HILOGD(LABEL_TEST, "PowerMgrMock048:End");
299 GTEST_LOG_(INFO) << "PowerMgrMock048: end.";
300 }
301
302 /**
303 * @tc.name: PowerMgrMock054
304 * @tc.desc: test ForceSuspendDevice by mock during Inactive
305 * @tc.type: FUNC
306 * @tc.require: issueI5MJZJ
307 */
308 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock054, TestSize.Level2)
309 {
310 GTEST_LOG_(INFO) << "PowerMgrMock054: start.";
311 POWER_HILOGD(LABEL_TEST, "PowerMgrMock054:Start.");
312
313 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
314 if (pms == nullptr) {
315 GTEST_LOG_(INFO) << "PowerMgrMock054: Failed to get PowerMgrService";
316 }
317
318 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
319 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _))
320 .Times(::testing::AtLeast(1))
321 .WillOnce(::testing::Return(ActionResult::SUCCESS));
322 pms->ForceSuspendDevice(0);
323 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
324 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
325
326 POWER_HILOGD(LABEL_TEST, "PowerMgrMock054:End.");
327 GTEST_LOG_(INFO) << "PowerMgrMock054: end.";
328 }
329
330 /**
331 * @tc.name: PowerMgrMock062
332 * @tc.desc: test Screen RunningLock by mock
333 * @tc.type: FUNC
334 * @tc.require: issueI5MJZJ
335 */
336 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock062, TestSize.Level2)
337 {
338 GTEST_LOG_(INFO) << "PowerMgrMock062: start.";
339 POWER_HILOGD(LABEL_TEST, "PowerMgrMock062:Start.");
340
341 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
342 if (pms == nullptr) {
343 GTEST_LOG_(INFO) << "PowerMgrMock062: Failed to get PowerMgrService";
344 }
345
346 sptr<IRemoteObject> token = new RunningLockTokenStub();
347 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
348 pms->CreateRunningLock(token, info);
349
350 pms->Lock(token, info, 0);
351 EXPECT_EQ(pms->IsUsed(token), true);
352
353 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
354 .Times(::testing::AtLeast(1))
355 .WillOnce(::testing::Return(ActionResult::SUCCESS));
356
357 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(1);
358 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
359 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
360
361 pms->UnLock(token);
362 EXPECT_EQ(pms->IsUsed(token), false);
363 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
364
365 POWER_HILOGD(LABEL_TEST, "PowerMgrMock062:End.");
366 GTEST_LOG_(INFO) << "PowerMgrMock062: end.";
367 }
368
369 /**
370 * @tc.name: PowerMgrMock063
371 * @tc.desc: test Screen RunningLock by mock
372 * @tc.type: FUNC
373 * @tc.require: issueI5MJZJ
374 */
375 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock063, TestSize.Level2)
376 {
377 GTEST_LOG_(INFO) << "PowerMgrMock063: start.";
378 POWER_HILOGD(LABEL_TEST, "PowerMgrMock063:Start.");
379
380 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
381 if (pms == nullptr) {
382 GTEST_LOG_(INFO) << "PowerMgrMock063: Failed to get PowerMgrService";
383 }
384
385 sptr<IRemoteObject> token = new RunningLockTokenStub();
386 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN);
387 pms->CreateRunningLock(token, info);
388
389 pms->Lock(token, info, 0);
390 EXPECT_EQ(pms->IsUsed(token), true);
391
392 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
393 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
394 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
395
396 pms->UnLock(token);
397 EXPECT_EQ(pms->IsUsed(token), false);
398 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
399
400 POWER_HILOGD(LABEL_TEST, "PowerMgrMock063:End.");
401 GTEST_LOG_(INFO) << "PowerMgrMock063: end.";
402 }
403
404 /**
405 * @tc.name: PowerMgrMock066
406 * @tc.desc: test background RunningLock by mock
407 * @tc.type: FUNC
408 * @tc.require: issueI5MJZJ
409 */
410 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock066, TestSize.Level2)
411 {
412 GTEST_LOG_(INFO) << "PowerMgrMock066: start.";
413 POWER_HILOGD(LABEL_TEST, "PowerMgrMock066:Start.");
414
415 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
416 if (pms == nullptr) {
417 GTEST_LOG_(INFO) << "PowerMgrMock066: Failed to get PowerMgrService";
418 }
419
420 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
421 sptr<IRemoteObject> token = new RunningLockTokenStub();
422 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
423 pms->CreateRunningLock(token, info);
424
425 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
426 pms->Lock(token, info, 0);
427 EXPECT_EQ(pms->IsUsed(token), true);
428
429 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
430 pms->UnLock(token);
431 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
432 sleep((REFRESHACTIVITY_WAIT_TIME_S * DOUBLE_TIMES / TEST_RATE) + 1);
433 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
434 sleep((REFRESHACTIVITY_WAIT_TIME_S / TEST_RATE) + 1);
435 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
436 EXPECT_EQ(pms->IsUsed(token), false);
437 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(1);
438 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
439 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
440
441 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
442 POWER_HILOGD(LABEL_TEST, "PowerMgrMock066:End.");
443 GTEST_LOG_(INFO) << "PowerMgrMock066: end.";
444 }
445
446 /**
447 * @tc.name: PowerMgrMock070
448 * @tc.desc: test background RunningLock by mock
449 * @tc.type: FUNC
450 * @tc.require: issueI5MJZJ
451 */
452 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock070, TestSize.Level2)
453 {
454 GTEST_LOG_(INFO) << "PowerMgrMock070: start.";
455 POWER_HILOGD(LABEL_TEST, "PowerMgrMock070:Start.");
456
457 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
458 if (pms == nullptr) {
459 GTEST_LOG_(INFO) << "PowerMgrMock070: Failed to get PowerMgrService";
460 }
461
462 sptr<IRemoteObject> token = new RunningLockTokenStub();
463 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND);
464 pms->CreateRunningLock(token, info);
465
466 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
467 pms->Lock(token, info, 0);
468 EXPECT_EQ(pms->IsUsed(token), true);
469
470 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
471 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
472 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
473 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
474
475 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
476 pms->UnLock(token);
477 EXPECT_EQ(pms->IsUsed(token), false);
478 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
479
480 POWER_HILOGD(LABEL_TEST, "PowerMgrMock070:End.");
481 GTEST_LOG_(INFO) << "PowerMgrMock070: end.";
482 }
483
484 /**
485 * @tc.name: PowerMgrMock071
486 * @tc.desc: test proximity screen control RunningLock by mock
487 * @tc.type: FUNC
488 * @tc.require: issueI5MJZJ
489 */
490 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock071, TestSize.Level2)
491 {
492 GTEST_LOG_(INFO) << "PowerMgrMock071: start.";
493 POWER_HILOGD(LABEL_TEST, "PowerMgrMock071:Start.");
494
495 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
496 if (pms == nullptr) {
497 GTEST_LOG_(INFO) << "PowerMgrMock071: Failed to get PowerMgrService";
498 }
499
500 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
501 sptr<IRemoteObject> token = new RunningLockTokenStub();
502 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
503 pms->CreateRunningLock(token, info);
504 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
505 .Times(::testing::AtLeast(1))
506 .WillOnce(::testing::Return(ActionResult::SUCCESS));
507 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
508 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
509 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
510 .Times(1)
511 .WillOnce(::testing::Return(ActionResult::SUCCESS));
512 sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND);
513 pms->Lock(token, info, 0);
514 EXPECT_EQ(pms->IsUsed(token), true);
515 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
516
517 pms->UnLock(token);
518 EXPECT_EQ(pms->IsUsed(token), false);
519
520 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
521 POWER_HILOGD(LABEL_TEST, "PowerMgrMock071:End.");
522 GTEST_LOG_(INFO) << "PowerMgrMock071: end.";
523 }
524
525 /**
526 * @tc.name: PowerMgrMock072
527 * @tc.desc: test proximity screen control RunningLock by mock
528 * @tc.type: FUNC
529 * @tc.require: issueI5MJZJ
530 */
531 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock072, TestSize.Level2)
532 {
533 GTEST_LOG_(INFO) << "PowerMgrMock072: start.";
534 POWER_HILOGD(LABEL_TEST, "PowerMgrMock072:Start.");
535
536 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
537 if (pms == nullptr) {
538 GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService";
539 }
540
541 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
542 sptr<IRemoteObject> token = new RunningLockTokenStub();
543 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
544 pms->CreateRunningLock(token, info);
545 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
546 EXPECT_EQ(pms->ForceSuspendDevice(0), true);
547 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
548 .Times(1)
549 .WillOnce(::testing::Return(ActionResult::SUCCESS));
550 sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND);
551 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
552 pms->Lock(token, info, 0);
553 EXPECT_EQ(pms->IsUsed(token), true);
554 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
555 pms->UnLock(token);
556 EXPECT_EQ(pms->IsUsed(token), false);
557
558 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
559 POWER_HILOGD(LABEL_TEST, "PowerMgrMock072:End.");
560 GTEST_LOG_(INFO) << "PowerMgrMock072: end.";
561 }
562
563 /**
564 * @tc.name: PowerMgrMock073
565 * @tc.desc: test proximity screen control RunningLock by mock
566 * @tc.type: FUNC
567 * @tc.require: issueI5MJZJ
568 */
569 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock073, TestSize.Level2)
570 {
571 GTEST_LOG_(INFO) << "PowerMgrMock073: start.";
572 POWER_HILOGD(LABEL_TEST, "PowerMgrMock073:Start.");
573
574 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
575 if (pms == nullptr) {
576 GTEST_LOG_(INFO) << "PowerMgrMock073: Failed to get PowerMgrService";
577 }
578
579 pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
580 sptr<IRemoteObject> token = new RunningLockTokenStub();
581 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
582 pms->CreateRunningLock(token, info);
583 pms->Lock(token, info, 0);
584 EXPECT_EQ(pms->IsUsed(token), true);
585 sleep(SLEEP_WAIT_TIME_S);
586
587 pms->UnLock(token);
588 EXPECT_EQ(pms->IsUsed(token), false);
589 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
590 sleep((REFRESHACTIVITY_WAIT_TIME_S * DOUBLE_TIMES / TEST_RATE) + 1);
591 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
592 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
593 .Times(::testing::AtLeast(1))
594 .WillOnce(::testing::Return(ActionResult::SUCCESS));
595 sleep((REFRESHACTIVITY_WAIT_TIME_S / TEST_RATE) + ONE_SECOND);
596 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
597 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
598 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
599 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
600 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
601
602 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
603 POWER_HILOGD(LABEL_TEST, "PowerMgrMock073:End.");
604 GTEST_LOG_(INFO) << "PowerMgrMock073: end.";
605 }
606
607 /**
608 * @tc.name: PowerMgrMock074
609 * @tc.desc: test proximity RunningLock by mock
610 * @tc.type: FUNC
611 * @tc.require: issueI5MJZJ
612 */
613 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock074, TestSize.Level2)
614 {
615 GTEST_LOG_(INFO) << "PowerMgrMock074: start.";
616 POWER_HILOGD(LABEL_TEST, "PowerMgrMock074:Start.");
617
618 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
619 if (pms == nullptr) {
620 GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService";
621 }
622
623 sptr<IRemoteObject> token = new RunningLockTokenStub();
624 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
625 pms->CreateRunningLock(token, info);
626
627 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
628 pms->Lock(token, info, 0);
629 EXPECT_EQ(pms->IsUsed(token), true);
630 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
631
632 POWER_HILOGD(LABEL_TEST, "PowerMgrMock074:End");
633 GTEST_LOG_(INFO) << "PowerMgrMock074: end";
634 }
635
636 /**
637 * @tc.name: PowerMgrMock075
638 * @tc.desc: test proximity RunningLock by mock
639 * @tc.type: FUNC
640 * @tc.require: issueI5MJZJ
641 */
642 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock075, TestSize.Level2)
643 {
644 GTEST_LOG_(INFO) << "PowerMgrMock075: start.";
645 POWER_HILOGD(LABEL_TEST, "PowerMgrMock075:Start.");
646
647 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
648 if (pms == nullptr) {
649 GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService";
650 }
651
652 sptr<IRemoteObject> token = new RunningLockTokenStub();
653 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
654 pms->CreateRunningLock(token, info);
655 pms->Lock(token, info, 0);
656 EXPECT_EQ(pms->IsUsed(token), true);
657 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
658 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
659
660 POWER_HILOGD(LABEL_TEST, "PowerMgrMock075:End.");
661 GTEST_LOG_(INFO) << "PowerMgrMock075: end.";
662 }
663
664 /**
665 * @tc.name: PowerMgrMock076
666 * @tc.desc: test proximity RunningLock by mock
667 * @tc.type: FUNC
668 * @tc.require: issueI5MJZJ
669 */
670 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock076, TestSize.Level2)
671 {
672 int i;
673 GTEST_LOG_(INFO) << "PowerMgrMock076: start.";
674 POWER_HILOGD(LABEL_TEST, "PowerMgrMock076:Start.");
675
676 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
677 if (pms == nullptr) {
678 GTEST_LOG_(INFO) << "PowerMgrMock076: Failed to get PowerMgrService";
679 }
680
681 pms->SetDisplayOffTime(ASYNC_WAIT_TIME_S * 1000);
682 sptr<IRemoteObject> token = new RunningLockTokenStub();
683 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
684 pms->CreateRunningLock(token, info);
685 for (i = 0; i < 10; i++) {
686 pms->Lock(token, info, 0);
687 EXPECT_EQ(pms->IsUsed(token), true);
688 pms->UnLock(token);
689 EXPECT_EQ(pms->IsUsed(token), false);
690 }
691 pms->Lock(token, info, 0);
692 EXPECT_EQ(pms->IsUsed(token), true);
693 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
694 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
695
696 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
697 POWER_HILOGD(LABEL_TEST, "PowerMgrMock076:End.");
698 GTEST_LOG_(INFO) << "PowerMgrMock076: end.";
699 }
700
701 /**
702 * @tc.name: PowerMgrMock077
703 * @tc.desc: test proximity RunningLock by mock
704 * @tc.type: FUNC
705 * @tc.require: issueI5MJZJ
706 */
707 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock077, TestSize.Level2)
708 {
709 GTEST_LOG_(INFO) << "PowerMgrMock077: start.";
710 POWER_HILOGD(LABEL_TEST, "PowerMgrMock077:Start.");
711
712 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
713 if (pms == nullptr) {
714 GTEST_LOG_(INFO) << "PowerMgrMock077: Failed to get PowerMgrService";
715 }
716
717 sptr<IRemoteObject> token = new RunningLockTokenStub();
718 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
719 pms->CreateRunningLock(token, info);
720 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
721 pms->Lock(token, info, 0);
722 EXPECT_EQ(pms->IsUsed(token), true);
723 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
724 .Times(::testing::AtLeast(1))
725 .WillOnce(::testing::Return(ActionResult::SUCCESS));
726 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
727 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
728 sleep(SLEEP_WAIT_TIME_S + 1);
729 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
730 sleep((SCREEN_OFF_WAIT_TIME_S * DOUBLE_TIMES / TEST_RATE) + ONE_SECOND);
731 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
732 sleep((SCREEN_OFF_WAIT_TIME_S / TEST_RATE) + ONE_SECOND);
733 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
734 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
735
736 POWER_HILOGD(LABEL_TEST, "PowerMgrMock077:End.");
737 GTEST_LOG_(INFO) << "PowerMgrMock077: end.";
738 }
739
740 /**
741 * @tc.name: PowerMgrMock078
742 * @tc.desc: test proximity RunningLock by mock
743 * @tc.type: FUNC
744 * @tc.require: issueI5MJZJ
745 */
746 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock078, TestSize.Level2)
747 {
748 GTEST_LOG_(INFO) << "PowerMgrMock078: start.";
749 POWER_HILOGD(LABEL_TEST, "PowerMgrMock078:Start.");
750
751 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
752 if (pms == nullptr) {
753 GTEST_LOG_(INFO) << "PowerMgrMock078: Failed to get PowerMgrService";
754 }
755
756 sptr<IRemoteObject> token = new RunningLockTokenStub();
757 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
758 pms->CreateRunningLock(token, info);
759 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
760 pms->Lock(token, info, 0);
761 EXPECT_EQ(pms->IsUsed(token), true);
762
763 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
764 pms->ForceSuspendDevice(0);
765 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
766
767 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
768 pms->UnLock(token);
769 EXPECT_EQ(pms->IsUsed(token), false);
770
771 POWER_HILOGD(LABEL_TEST, "PowerMgrMock078:End.");
772 GTEST_LOG_(INFO) << "PowerMgrMock078: end.";
773 }
774
775 /**
776 * @tc.name: PowerMgrMock079
777 * @tc.desc: test proximity RunningLock by mock
778 * @tc.type: FUNC
779 * @tc.require: issueI5MJZJ
780 */
781 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock079, TestSize.Level2)
782 {
783 GTEST_LOG_(INFO) << "PowerMgrMock079: start.";
784 POWER_HILOGD(LABEL_TEST, "PowerMgrMock079:Start.");
785
786 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
787 if (pms == nullptr) {
788 GTEST_LOG_(INFO) << "PowerMgrMock079: Failed to get PowerMgrService";
789 }
790
791 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
792 sptr<IRemoteObject> token = new RunningLockTokenStub();
793 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
794 pms->CreateRunningLock(token, info);
795
796 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
797 pms->Lock(token, info, 0);
798 EXPECT_EQ(pms->IsUsed(token), true);
799
800 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
801 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
802
803 POWER_HILOGD(LABEL_TEST, "PowerMgrMock079:End.");
804 GTEST_LOG_(INFO) << "PowerMgrMock079: end.";
805 }
806
807 /**
808 * @tc.name: PowerMgrMock080
809 * @tc.desc: test Auto SuspendDevice by mock after 5s
810 * @tc.type: FUNC
811 * @tc.require: issueI5MJZJ
812 */
813 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock080, TestSize.Level2)
814 {
815 int64_t time = 50;
816 GTEST_LOG_(INFO) << "PowerMgrMock080: start.";
817 POWER_HILOGD(LABEL_TEST, "PowerMgrMock080:Start.");
818
819 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
820 if (pms == nullptr) {
821 GTEST_LOG_(INFO) << "PowerMgrMock080: Failed to get PowerMgrService";
822 }
823
824 pms->SetDisplayOffTime(time);
825 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
826 sleep(((time / TRANSFER_MS_TO_S) * DOUBLE_TIMES / TEST_RATE) + ONE_SECOND);
827 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
828 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
829 .Times(::testing::AtLeast(1))
830 .WillOnce(::testing::Return(ActionResult::SUCCESS));
831 sleep(time / TRANSFER_MS_TO_S / TEST_RATE + ONE_SECOND);
832 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
833 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
834 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
835
836 POWER_HILOGD(LABEL_TEST, "PowerMgrMock080:End.");
837 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
838 GTEST_LOG_(INFO) << "PowerMgrMock080: end.";
839 }
840 }
841