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 pms->SetDisplayOffTime(ASYNC_WAIT_TIME_S * 1000);
624 sptr<IRemoteObject> token = new RunningLockTokenStub();
625 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
626 pms->CreateRunningLock(token, info);
627
628 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
629 pms->Lock(token, info, 0);
630 EXPECT_EQ(pms->IsUsed(token), true);
631 sleep(ASYNC_WAIT_TIME_S + ONE_SECOND);
632 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
633 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
634 .Times(1)
635 .WillOnce(::testing::Return(ActionResult::SUCCESS));
636 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
637 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
638
639 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
640 POWER_HILOGD(LABEL_TEST, "PowerMgrMock074:End.");
641 GTEST_LOG_(INFO) << "PowerMgrMock074: end.";
642 }
643
644 /**
645 * @tc.name: PowerMgrMock075
646 * @tc.desc: test proximity RunningLock by mock
647 * @tc.type: FUNC
648 * @tc.require: issueI5MJZJ
649 */
650 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock075, TestSize.Level2)
651 {
652 GTEST_LOG_(INFO) << "PowerMgrMock075: start.";
653 POWER_HILOGD(LABEL_TEST, "PowerMgrMock075:Start.");
654
655 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
656 if (pms == nullptr) {
657 GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService";
658 }
659
660 sptr<IRemoteObject> token = new RunningLockTokenStub();
661 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
662 pms->CreateRunningLock(token, info);
663 pms->Lock(token, info, 0);
664 EXPECT_EQ(pms->IsUsed(token), true);
665 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
666 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
667 .Times(1)
668 .WillOnce(::testing::Return(ActionResult::SUCCESS));
669 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
670 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
671 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
672
673 POWER_HILOGD(LABEL_TEST, "PowerMgrMock075:End.");
674 GTEST_LOG_(INFO) << "PowerMgrMock075: end.";
675 }
676
677 /**
678 * @tc.name: PowerMgrMock076
679 * @tc.desc: test proximity RunningLock by mock
680 * @tc.type: FUNC
681 * @tc.require: issueI5MJZJ
682 */
683 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock076, TestSize.Level2)
684 {
685 int i;
686 GTEST_LOG_(INFO) << "PowerMgrMock076: start.";
687 POWER_HILOGD(LABEL_TEST, "PowerMgrMock076:Start.");
688
689 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
690 if (pms == nullptr) {
691 GTEST_LOG_(INFO) << "PowerMgrMock076: Failed to get PowerMgrService";
692 }
693
694 pms->SetDisplayOffTime(ASYNC_WAIT_TIME_S * 1000);
695 sptr<IRemoteObject> token = new RunningLockTokenStub();
696 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
697 pms->CreateRunningLock(token, info);
698 for (i = 0; i < 10; i++) {
699 pms->Lock(token, info, 0);
700 EXPECT_EQ(pms->IsUsed(token), true);
701 pms->UnLock(token);
702 EXPECT_EQ(pms->IsUsed(token), false);
703 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
704 }
705 pms->Lock(token, info, 0);
706 EXPECT_EQ(pms->IsUsed(token), true);
707 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
708 .Times(1)
709 .WillOnce(::testing::Return(ActionResult::SUCCESS));
710 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, _)).Times(0);
711 pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
712 EXPECT_EQ(PowerState::INACTIVE, pms->GetState());
713
714 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
715 POWER_HILOGD(LABEL_TEST, "PowerMgrMock076:End.");
716 GTEST_LOG_(INFO) << "PowerMgrMock076: end.";
717 }
718
719 /**
720 * @tc.name: PowerMgrMock077
721 * @tc.desc: test proximity RunningLock by mock
722 * @tc.type: FUNC
723 * @tc.require: issueI5MJZJ
724 */
725 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock077, TestSize.Level2)
726 {
727 GTEST_LOG_(INFO) << "PowerMgrMock077: start.";
728 POWER_HILOGD(LABEL_TEST, "PowerMgrMock077:Start.");
729
730 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
731 if (pms == nullptr) {
732 GTEST_LOG_(INFO) << "PowerMgrMock077: Failed to get PowerMgrService";
733 }
734
735 sptr<IRemoteObject> token = new RunningLockTokenStub();
736 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
737 pms->CreateRunningLock(token, info);
738 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
739 pms->Lock(token, info, 0);
740 EXPECT_EQ(pms->IsUsed(token), true);
741 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
742 .Times(::testing::AtLeast(1))
743 .WillOnce(::testing::Return(ActionResult::SUCCESS));
744 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
745 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
746 sleep(SLEEP_WAIT_TIME_S + 1);
747 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
748 sleep((SCREEN_OFF_WAIT_TIME_S * DOUBLE_TIMES / TEST_RATE) + ONE_SECOND);
749 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
750 sleep((SCREEN_OFF_WAIT_TIME_S / TEST_RATE) + ONE_SECOND);
751 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
752 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
753
754 POWER_HILOGD(LABEL_TEST, "PowerMgrMock077:End.");
755 GTEST_LOG_(INFO) << "PowerMgrMock077: end.";
756 }
757
758 /**
759 * @tc.name: PowerMgrMock078
760 * @tc.desc: test proximity RunningLock by mock
761 * @tc.type: FUNC
762 * @tc.require: issueI5MJZJ
763 */
764 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock078, TestSize.Level2)
765 {
766 GTEST_LOG_(INFO) << "PowerMgrMock078: start.";
767 POWER_HILOGD(LABEL_TEST, "PowerMgrMock078:Start.");
768
769 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
770 if (pms == nullptr) {
771 GTEST_LOG_(INFO) << "PowerMgrMock078: Failed to get PowerMgrService";
772 }
773
774 sptr<IRemoteObject> token = new RunningLockTokenStub();
775 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
776 pms->CreateRunningLock(token, info);
777 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
778 pms->Lock(token, info, 0);
779 EXPECT_EQ(pms->IsUsed(token), true);
780
781 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, true)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
782 pms->ForceSuspendDevice(0);
783 EXPECT_EQ(PowerState::SLEEP, pms->GetState());
784
785 EXPECT_CALL(*g_lockAction, Unlock(_, _)).Times(1);
786 pms->UnLock(token);
787 EXPECT_EQ(pms->IsUsed(token), false);
788
789 POWER_HILOGD(LABEL_TEST, "PowerMgrMock078:End.");
790 GTEST_LOG_(INFO) << "PowerMgrMock078: end.";
791 }
792
793 /**
794 * @tc.name: PowerMgrMock079
795 * @tc.desc: test proximity RunningLock by mock
796 * @tc.type: FUNC
797 * @tc.require: issueI5MJZJ
798 */
799 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock079, TestSize.Level2)
800 {
801 GTEST_LOG_(INFO) << "PowerMgrMock079: start.";
802 POWER_HILOGD(LABEL_TEST, "PowerMgrMock079:Start.");
803
804 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
805 if (pms == nullptr) {
806 GTEST_LOG_(INFO) << "PowerMgrMock079: Failed to get PowerMgrService";
807 }
808
809 pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
810 sptr<IRemoteObject> token = new RunningLockTokenStub();
811 RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
812 pms->CreateRunningLock(token, info);
813
814 EXPECT_CALL(*g_lockAction, Lock(_, _)).Times(1);
815 pms->Lock(token, info, 0);
816 EXPECT_EQ(pms->IsUsed(token), true);
817
818 pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
819 EXPECT_EQ(PowerState::AWAKE, pms->GetState());
820
821 POWER_HILOGD(LABEL_TEST, "PowerMgrMock079:End.");
822 GTEST_LOG_(INFO) << "PowerMgrMock079: end.";
823 }
824
825 /**
826 * @tc.name: PowerMgrMock080
827 * @tc.desc: test Auto SuspendDevice by mock after 5s
828 * @tc.type: FUNC
829 * @tc.require: issueI5MJZJ
830 */
831 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock080, TestSize.Level2)
832 {
833 int64_t time = 50;
834 GTEST_LOG_(INFO) << "PowerMgrMock080: start.";
835 POWER_HILOGD(LABEL_TEST, "PowerMgrMock080:Start.");
836
837 sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
838 if (pms == nullptr) {
839 GTEST_LOG_(INFO) << "PowerMgrMock080: Failed to get PowerMgrService";
840 }
841
842 pms->SetDisplayOffTime(time);
843 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_ON));
844 sleep(((time / TRANSFER_MS_TO_S) * DOUBLE_TIMES / TEST_RATE) + ONE_SECOND);
845 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM));
846 EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
847 .Times(::testing::AtLeast(1))
848 .WillOnce(::testing::Return(ActionResult::SUCCESS));
849 sleep(time / TRANSFER_MS_TO_S / TEST_RATE + ONE_SECOND);
850 EXPECT_CALL(*g_stateAction, GoToSleep(_, _, false)).Times(1).WillOnce(::testing::Return(ActionResult::SUCCESS));
851 ON_CALL(*g_stateAction, GetDisplayState()).WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF));
852 sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
853
854 POWER_HILOGD(LABEL_TEST, "PowerMgrMock080:End.");
855 pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
856 GTEST_LOG_(INFO) << "PowerMgrMock080: end.";
857 }
858 }
859