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_HILOGI(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_HILOGI(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_HILOGI(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), PowerErrors::ERR_OK);
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_HILOGI(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);
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_HILOGI(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_HILOGI(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);
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_HILOGI(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_HILOGI(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_HILOGI(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_HILOGI(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);
244     EXPECT_EQ(pms->IsUsed(token), true);
245 
246     EXPECT_EQ(pms->ForceSuspendDevice(0), PowerErrors::ERR_OK);
247     sleep(SLEEP_WAIT_TIME_S + ONE_SECOND);
248 
249     pms->UnLock(token);
250     EXPECT_EQ(pms->IsUsed(token), false);
251 
252     POWER_HILOGI(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_HILOGI(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(::testing::AtLeast(1))
289         .WillOnce(::testing::Return(ActionResult::SUCCESS));
290     sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND);
291     pms->Lock(token);
292     pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, std::string("test"));
293     EXPECT_EQ(pms->IsUsed(token), true);
294 
295     pms->UnLock(token);
296     EXPECT_EQ(pms->IsUsed(token), false);
297 
298     pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
299     POWER_HILOGI(LABEL_TEST, "PowerMgrMock071:End");
300     GTEST_LOG_(INFO) << "PowerMgrMock071: end";
301 }
302 
303 /**
304  * @tc.name: PowerMgrMock072
305  * @tc.desc: test proximity screen control RunningLock by mock
306  * @tc.type: FUNC
307  * @tc.require: issueI5MJZJ
308  */
309 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock072, TestSize.Level2)
310 {
311     GTEST_LOG_(INFO) << "PowerMgrMock072: start";
312     POWER_HILOGI(LABEL_TEST, "PowerMgrMock072:Start");
313 
314     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
315     if (pms == nullptr) {
316         GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService";
317     }
318 
319     pms->SetDisplayOffTime(SET_DISPLAY_OFF_TIME_MS);
320     sptr<IRemoteObject> token = new RunningLockTokenStub();
321     RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
322     pms->CreateRunningLock(token, info);
323     EXPECT_EQ(pms->ForceSuspendDevice(0), PowerErrors::ERR_OK);
324     EXPECT_CALL(*g_stateAction, GetDisplayState())
325         .Times(::testing::AtLeast(1))
326         .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
327     EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
328         .Times(::testing::AtLeast(1))
329         .WillOnce(::testing::Return(ActionResult::SUCCESS));
330     sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND);
331     pms->Lock(token);
332     pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, std::string("test"));
333     EXPECT_EQ(pms->IsUsed(token), true);
334     pms->UnLock(token);
335     EXPECT_EQ(pms->IsUsed(token), false);
336 
337     pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
338     POWER_HILOGI(LABEL_TEST, "PowerMgrMock072:End");
339     GTEST_LOG_(INFO) << "PowerMgrMock072: end";
340 }
341 
342 /**
343  * @tc.name: PowerMgrMock074
344  * @tc.desc: test proximity RunningLock by mock
345  * @tc.type: FUNC
346  * @tc.require: issueI5MJZJ
347  */
348 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock074, TestSize.Level2)
349 {
350     GTEST_LOG_(INFO) << "PowerMgrMock074: start";
351     POWER_HILOGI(LABEL_TEST, "PowerMgrMock074:Start");
352 
353     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
354     if (pms == nullptr) {
355         GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService";
356     }
357 
358     sptr<IRemoteObject> token = new RunningLockTokenStub();
359     RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
360     pms->CreateRunningLock(token, info);
361 
362     pms->Lock(token);
363     EXPECT_EQ(pms->IsUsed(token), true);
364     pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
365     pms->UnLock(token);
366 
367     POWER_HILOGI(LABEL_TEST, "PowerMgrMock074:End");
368     GTEST_LOG_(INFO) << "PowerMgrMock074: end";
369 }
370 
371 /**
372  * @tc.name: PowerMgrMock075
373  * @tc.desc: test proximity RunningLock by mock
374  * @tc.type: FUNC
375  * @tc.require: issueI5MJZJ
376  */
377 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock075, TestSize.Level2)
378 {
379     GTEST_LOG_(INFO) << "PowerMgrMock075: start";
380     POWER_HILOGI(LABEL_TEST, "PowerMgrMock075:Start");
381 
382     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
383     if (pms == nullptr) {
384         GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService";
385     }
386 
387     sptr<IRemoteObject> token = new RunningLockTokenStub();
388     RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
389     pms->CreateRunningLock(token, info);
390     pms->Lock(token);
391     pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, std::string("test"));
392     EXPECT_EQ(pms->IsUsed(token), true);
393     EXPECT_EQ(PowerState::AWAKE, pms->GetState());
394     pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE);
395     pms->UnLock(token);
396 
397     POWER_HILOGI(LABEL_TEST, "PowerMgrMock075:End");
398     GTEST_LOG_(INFO) << "PowerMgrMock075: end";
399 }
400 
401 /**
402  * @tc.name: PowerMgrMock076
403  * @tc.desc: test proximity RunningLock by mock
404  * @tc.type: FUNC
405  * @tc.require: issueI5MJZJ
406  */
407 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock076, TestSize.Level2)
408 {
409     int i;
410     GTEST_LOG_(INFO) << "PowerMgrMock076: start";
411     POWER_HILOGI(LABEL_TEST, "PowerMgrMock076:Start");
412 
413     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
414     if (pms == nullptr) {
415         GTEST_LOG_(INFO) << "PowerMgrMock076: Failed to get PowerMgrService";
416     }
417 
418     pms->SetDisplayOffTime(ASYNC_WAIT_TIME_S * TEST_TIMES);
419     sptr<IRemoteObject> token = new RunningLockTokenStub();
420     RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
421     pms->CreateRunningLock(token, info);
422     for (i = 0; i < 10; i++) {
423         pms->Lock(token);
424         EXPECT_EQ(pms->IsUsed(token), true);
425         pms->UnLock(token);
426         EXPECT_EQ(pms->IsUsed(token), false);
427     }
428     pms->Lock(token);
429     EXPECT_EQ(pms->IsUsed(token), true);
430     pms->UnLock(token);
431 
432     pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME);
433     POWER_HILOGI(LABEL_TEST, "PowerMgrMock076:End");
434     GTEST_LOG_(INFO) << "PowerMgrMock076: end";
435 }
436 
437 /**
438  * @tc.name: PowerMgrMock078
439  * @tc.desc: test proximity RunningLock by mock
440  * @tc.type: FUNC
441  * @tc.require: issueI5MJZJ
442  */
443 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock078, TestSize.Level2)
444 {
445     GTEST_LOG_(INFO) << "PowerMgrMock078: start";
446     POWER_HILOGI(LABEL_TEST, "PowerMgrMock078:Start");
447 
448     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
449     if (pms == nullptr) {
450         GTEST_LOG_(INFO) << "PowerMgrMock078: Failed to get PowerMgrService";
451     }
452 
453     sptr<IRemoteObject> token = new RunningLockTokenStub();
454     RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
455     pms->CreateRunningLock(token, info);
456     pms->Lock(token);
457     EXPECT_EQ(pms->IsUsed(token), true);
458 
459     pms->ForceSuspendDevice(0);
460 
461     pms->UnLock(token);
462     EXPECT_EQ(pms->IsUsed(token), false);
463 
464     POWER_HILOGI(LABEL_TEST, "PowerMgrMock078:End");
465     GTEST_LOG_(INFO) << "PowerMgrMock078: end";
466 }
467 
468 /**
469  * @tc.name: PowerMgrMock079
470  * @tc.desc: test proximity RunningLock by mock
471  * @tc.type: FUNC
472  * @tc.require: issueI5MJZJ
473  */
474 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock079, TestSize.Level2)
475 {
476     GTEST_LOG_(INFO) << "PowerMgrMock079: start";
477     POWER_HILOGI(LABEL_TEST, "PowerMgrMock079:Start");
478 
479     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
480     if (pms == nullptr) {
481         GTEST_LOG_(INFO) << "PowerMgrMock079: Failed to get PowerMgrService";
482     }
483 
484     pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
485     sptr<IRemoteObject> token = new RunningLockTokenStub();
486     RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
487     pms->CreateRunningLock(token, info);
488 
489     pms->Lock(token);
490     EXPECT_EQ(pms->IsUsed(token), true);
491 
492     pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN, std::string("test"));
493     EXPECT_EQ(PowerState::AWAKE, pms->GetState());
494 
495     POWER_HILOGI(LABEL_TEST, "PowerMgrMock079:End");
496     GTEST_LOG_(INFO) << "PowerMgrMock079: end";
497 }
498 
499 /**
500  * @tc.name: PowerMgrMock081
501  * @tc.desc: test The display status and power status are inconsistent SuspendDevice
502  * @tc.type: FUNC
503  * @tc.require: issueI66HYP
504  */
505 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock081, TestSize.Level2)
506 {
507     GTEST_LOG_(INFO) << "PowerMgrMock081: start.";
508     POWER_HILOGI(LABEL_TEST, "PowerMgrMock081:Start.");
509 
510     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
511     ASSERT_TRUE(pms != nullptr);
512 
513     // Set the power status to INACTIVE
514     pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
515     EXPECT_TRUE(pms->GetState() == PowerState::INACTIVE || pms->GetState() == PowerState::SLEEP);
516 
517     // Analog display return DISPLAY_ON
518     EXPECT_CALL(*g_stateAction, GetDisplayState())
519         .Times(::testing::AtLeast(1))
520         .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_ON));
521     EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_))
522         .Times(::testing::AtLeast(1))
523         .WillOnce(::testing::Return(ActionResult::SUCCESS));
524     // The status is changed to display status ON, and the screen is off again
525     pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
526     EXPECT_TRUE(pms->GetState() == PowerState::INACTIVE || pms->GetState() == PowerState::SLEEP);
527 
528     POWER_HILOGI(LABEL_TEST, "PowerMgrMock081:End.");
529     GTEST_LOG_(INFO) << "PowerMgrMock081: end.";
530 }
531 
532 /**
533  * @tc.name: PowerMgrMock082
534  * @tc.desc: test The display status and power status are inconsistent WakeupDevice
535  * @tc.type: FUNC
536  * @tc.require: issueI66HYP
537  */
538 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock082, TestSize.Level2)
539 {
540     GTEST_LOG_(INFO) << "PowerMgrMock082: start.";
541     POWER_HILOGI(LABEL_TEST, "PowerMgrMock082:Start.");
542 
543     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
544     ASSERT_TRUE(pms != nullptr);
545 
546     // Set the power status to AWAKE
547     pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("PowerMgrMock082"));
548     EXPECT_TRUE(pms->GetState() == PowerState::AWAKE);
549 
550     // Analog display return DISPLAY_OFF
551     EXPECT_CALL(*g_stateAction, GetDisplayState())
552         .Times(::testing::AtLeast(1))
553         .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_OFF));
554     EXPECT_CALL(*g_stateAction, SetDisplayState(DisplayState::DISPLAY_ON, ::testing::_))
555         .Times(::testing::AtLeast(1))
556         .WillOnce(::testing::Return(ActionResult::SUCCESS));
557     // The status is changed to display status OFF, and the screen is off again
558     pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, std::string("PowerMgrMock082_Again"));
559     EXPECT_TRUE(pms->GetState() == PowerState::AWAKE);
560 
561     POWER_HILOGI(LABEL_TEST, "PowerMgrMock082:End.");
562     GTEST_LOG_(INFO) << "PowerMgrMock082: end.";
563 }
564 
565 /**
566  * @tc.name: PowerMgrMock083
567  * @tc.desc: test SetState will block transit from AWAKE to SLEEP/HIBERNATE
568  * @tc.type: FUNC
569  * @tc.require: issueI9AMZT
570  */
571 HWTEST_F(PowerMgrSTMockTest, PowerMgrMock083, TestSize.Level2)
572 {
573     GTEST_LOG_(INFO) << "PowerMgrMock083: start.";
574     POWER_HILOGI(LABEL_TEST, "PowerMgrMock083:Start.");
575 
576     vector<PowerState> sleepStates { PowerState::SLEEP, PowerState::HIBERNATE };
577 
578     sptr<PowerMgrService> pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
579     ASSERT_TRUE(pms != nullptr);
580     std::shared_ptr<PowerStateMachine> stateMachine = pms->GetPowerStateMachine();
581     ASSERT_TRUE(stateMachine != nullptr);
582 
583     // Analog display return DISPLAY_ON
584     EXPECT_CALL(*g_stateAction, GetDisplayState())
585     .Times(::testing::AtLeast(1))
586     .WillRepeatedly(::testing::Return(DisplayState::DISPLAY_ON));
587 
588     // Set the power state to AWAKE
589     auto ret = stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_INIT);
590     EXPECT_TRUE(stateMachine->GetState() == PowerState::AWAKE);
591 
592     for (auto targetState : sleepStates) {
593         // Set the power state to target state
594         auto ret = stateMachine->SetState(targetState, StateChangeReason::STATE_CHANGE_REASON_SYSTEM);
595         // SetState will block transit from AWAKE to these states, expect SetState fail
596         EXPECT_FALSE(ret);
597         EXPECT_TRUE(stateMachine->GetState() == PowerState::AWAKE);
598     }
599 
600     POWER_HILOGI(LABEL_TEST, "PowerMgrMock083:End.");
601     GTEST_LOG_(INFO) << "PowerMgrMock083: end.";
602 }
603 } // namespace
604