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_service_test.h"
17 
18 #include <csignal>
19 #include <iostream>
20 #include <thread>
21 
22 #include <if_system_ability_manager.h>
23 #include <ipc_skeleton.h>
24 #include <iservice_registry.h>
25 #include <string_ex.h>
26 #include <system_ability_definition.h>
27 
28 #include "power_common.h"
29 #include "power_mgr_client.h"
30 #include "power_mgr_service.h"
31 
32 using namespace testing::ext;
33 using namespace OHOS::PowerMgr;
34 using namespace OHOS;
35 using namespace std;
36 
SetUpTestCase(void)37 void PowerMgrServiceTest::SetUpTestCase(void)
38 {
39 }
40 
TearDownTestCase(void)41 void PowerMgrServiceTest::TearDownTestCase(void)
42 {
43 }
44 
SetUp(void)45 void PowerMgrServiceTest::SetUp(void)
46 {
47 }
48 
TearDown(void)49 void PowerMgrServiceTest::TearDown(void)
50 {
51 }
52 
53 namespace {
54 constexpr const int64_t STATE_WAIT_TIME_MS = 300;
55 constexpr const int64_t STATE_OFF_WAIT_TIME_MS = 2000;
56 /**
57  * @tc.name: PowerMgrService01
58  * @tc.desc: Test PowerMgrService service ready.
59  * @tc.type: FUNC
60  */
61 HWTEST_F (PowerMgrServiceTest, PowerMgrService001, TestSize.Level0)
62 {
63     sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
64     ASSERT_TRUE(sam != nullptr) << "PowerMgrService01 fail to get GetSystemAbilityManager";
65     sptr<IRemoteObject> remoteObject_ = sam->CheckSystemAbility(POWER_MANAGER_SERVICE_ID);
66     ASSERT_TRUE(remoteObject_ != nullptr) << "GetSystemAbility failed.";
67 }
68 
69 /**
70  * @tc.name: PowerMgrService002
71  * @tc.desc: Test PowerMgrService Start and stop.
72  * @tc.type: FUNC
73  */
74 HWTEST_F (PowerMgrServiceTest, PowerMgrService002, TestSize.Level0)
75 {
76     if (false) {
77         auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
78         ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService02 fail to get PowerMgrService";
79         ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is ready";
80         pmsTest_->OnStart();
81         ASSERT_TRUE(pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is not ready";
82         pmsTest_->OnStop();
83         ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ stop fail";
84         pmsTest_->OnStart();
85         ASSERT_TRUE(pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is not ready";
86         pmsTest_->OnStop();
87         ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ stop fail";
88     }
89 }
90 
91 /**
92  * @tc.name: PowerMgrService003
93  * @tc.desc: Test overrideScreenOffTime in screenon
94  * @tc.type: FUNC
95  */
96 HWTEST_F (PowerMgrServiceTest, PowerMgrService003, TestSize.Level0)
97 {
98     auto& powerMgrClient = PowerMgrClient::GetInstance();
99     powerMgrClient.WakeupDevice();
100     EXPECT_EQ(powerMgrClient.OverrideScreenOffTime(1000), PowerErrors::ERR_OK);
101     sleep(3);
102     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService003: Prepare Fail, Screen is ON.";
103     EXPECT_EQ(powerMgrClient.RestoreScreenOffTime(), PowerErrors::ERR_OK);
104     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService003 end.");
105 }
106 
107 /**
108  * @tc.name: PowerMgrService004
109  * @tc.desc: Test overrideScreenOffTime in screenon
110  * @tc.type: FUNC
111  */
112 HWTEST_F (PowerMgrServiceTest, PowerMgrService004, TestSize.Level0)
113 {
114     auto& powerMgrClient = PowerMgrClient::GetInstance();
115     powerMgrClient.WakeupDevice();
116     EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
117     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService004: Prepare Fail, Screen is ON.";
118 
119     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService004 end.");
120 }
121 
122 /**
123  * @tc.name: PowerMgrService005
124  * @tc.desc: Test overrideScreenOffTime in screenon
125  * @tc.type: FUNC
126  */
127 HWTEST_F (PowerMgrServiceTest, PowerMgrService005, TestSize.Level0)
128 {
129     auto& powerMgrClient = PowerMgrClient::GetInstance();
130     powerMgrClient.WakeupDevice();
131     EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
132     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService005: Prepare Fail, Screen is OFF.";
133 
134     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService005 end.");
135 }
136 
137 /**
138  * @tc.name: PowerMgrService006
139  * @tc.desc: Test overrideScreenOffTime in screenoff
140  * @tc.type: FUNC
141  */
142 HWTEST_F (PowerMgrServiceTest, PowerMgrService006, TestSize.Level0)
143 {
144     auto& powerMgrClient = PowerMgrClient::GetInstance();
145     powerMgrClient.SuspendDevice();
146     EXPECT_EQ(powerMgrClient.OverrideScreenOffTime(1000), PowerErrors::ERR_OK);
147     powerMgrClient.WakeupDevice();
148     sleep(5);
149     EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService006: Prepare Fail, Screen is ON.";
150     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService006 end.");
151 }
152 
153 /**
154  * @tc.name: PowerMgrService007
155  * @tc.desc: Test overrideScreenOffTime in screenoff
156  * @tc.type: FUNC
157  */
158 HWTEST_F (PowerMgrServiceTest, PowerMgrService007, TestSize.Level0)
159 {
160     auto& powerMgrClient = PowerMgrClient::GetInstance();
161     powerMgrClient.SuspendDevice();
162     EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
163     powerMgrClient.WakeupDevice();
164     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService007: Prepare Fail, Screen is ON.";
165 
166     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService007 end.");
167 }
168 
169 /**
170  * @tc.name: PowerMgrService008
171  * @tc.desc: Test overrideScreenOffTime in screenoff
172  * @tc.type: FUNC
173  */
174 HWTEST_F (PowerMgrServiceTest, PowerMgrService008, TestSize.Level0)
175 {
176     auto& powerMgrClient = PowerMgrClient::GetInstance();
177     powerMgrClient.SuspendDevice();
178     EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
179     powerMgrClient.WakeupDevice();
180     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService008: Prepare Fail, Screen is OFF.";
181 
182     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService008 end.");
183 }
184 
185 /**
186  * @tc.name: PowerMgrService009
187  * @tc.desc: Test restoreScreenOffTime in screenon
188  * @tc.type: FUNC
189  */
190 HWTEST_F (PowerMgrServiceTest, PowerMgrService009, TestSize.Level0)
191 {
192     auto& powerMgrClient = PowerMgrClient::GetInstance();
193     powerMgrClient.WakeupDevice();
194     EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000) == PowerErrors::ERR_OK);
195     EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
196     sleep(2);
197     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService009: Prepare Fail, Screen is OFF.";
198 
199     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService009 end.");
200 }
201 
202 /**
203  * @tc.name: PowerMgrService010
204  * @tc.desc: Test restoreScreenOffTime in screenon
205  * @tc.type: FUNC
206  */
207 HWTEST_F (PowerMgrServiceTest, PowerMgrService010, TestSize.Level0)
208 {
209     auto& powerMgrClient = PowerMgrClient::GetInstance();
210     powerMgrClient.WakeupDevice();
211     EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
212     EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
213     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService010: Prepare Fail, Screen is OFF.";
214 
215     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService010 end.");
216 }
217 
218 /**
219  * @tc.name: PowerMgrService011
220  * @tc.desc: Test restoreScreenOffTime in screenon
221  * @tc.type: FUNC
222  */
223 HWTEST_F (PowerMgrServiceTest, PowerMgrService011, TestSize.Level0)
224 {
225     auto& powerMgrClient = PowerMgrClient::GetInstance();
226     powerMgrClient.WakeupDevice();
227     EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);;
228     EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
229     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService011: Prepare Fail, Screen is OFF.";
230 
231     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService011 end.");
232 }
233 
234 /**
235  * @tc.name: PowerMgrService012
236  * @tc.desc: Test restoreScreenOffTime in screenoff
237  * @tc.type: FUNC
238  */
239 HWTEST_F (PowerMgrServiceTest, PowerMgrService012, TestSize.Level0)
240 {
241     auto& powerMgrClient = PowerMgrClient::GetInstance();
242     powerMgrClient.SuspendDevice();
243     EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000) == PowerErrors::ERR_OK);
244     EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
245     powerMgrClient.WakeupDevice();
246     sleep(2);
247     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService012: Prepare Fail, Screen is OFF.";
248 
249     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService012 end.");
250 }
251 
252 /**
253  * @tc.name: PowerMgrService013
254  * @tc.desc: Test restoreScreenOffTime in screenoff
255  * @tc.type: FUNC
256  */
257 HWTEST_F (PowerMgrServiceTest, PowerMgrService013, TestSize.Level0)
258 {
259     auto& powerMgrClient = PowerMgrClient::GetInstance();
260     powerMgrClient.SuspendDevice();
261     EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
262     EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
263     powerMgrClient.WakeupDevice();
264     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService013: Prepare Fail, Screen is OFF.";
265 
266     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService013 end.");
267 }
268 
269 /**
270  * @tc.name: PowerMgrService014
271  * @tc.desc: Test restoreScreenOffTime in screenoff
272  * @tc.type: FUNC
273  */
274 HWTEST_F (PowerMgrServiceTest, PowerMgrService014, TestSize.Level0)
275 {
276     auto& powerMgrClient = PowerMgrClient::GetInstance();
277     powerMgrClient.SuspendDevice();
278     EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
279     EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
280     powerMgrClient.WakeupDevice();
281     EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService014: Prepare Fail, Screen is OFF.";
282 
283     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService014 end.");
284 }
285 
286 /**
287  * @tc.name: PowerMgrService015
288  * @tc.desc: Test Dump
289  * @tc.type: FUNC
290  * @tc.require: issueI650CX
291  */
292 HWTEST_F(PowerMgrServiceTest, PowerMgrService015, TestSize.Level2)
293 {
294     auto& powerMgrClient = PowerMgrClient::GetInstance();
295     std::vector<std::string> dumpArgs {};
296     std::string expectedDebugInfo = "Power manager dump options";
297     std::string actualDebugInfo = powerMgrClient.Dump(dumpArgs);
298     auto index = actualDebugInfo.find(expectedDebugInfo);
299     EXPECT_TRUE(index != string::npos);
300 }
301 
302 /**
303  * @tc.name: PowerMgrService016
304  * @tc.desc: Test IsStandby
305  * @tc.type: FUNC
306  * @tc.require: issueI7QHBE
307  */
308 HWTEST_F(PowerMgrServiceTest, PowerMgrService016, TestSize.Level2)
309 {
310     auto& powerMgrClient = PowerMgrClient::GetInstance();
311     bool standby = false;
312     PowerErrors ret = powerMgrClient.IsStandby(standby);
313     bool testPassed = (ret == PowerErrors::ERR_OK || ret == PowerErrors::ERR_CONNECTION_FAIL);
314     EXPECT_TRUE(testPassed);
315     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService016 end.");
316 }
317 
318 /**
319  * @tc.name: PowerMgrService017
320  * @tc.desc: Test QueryRunningLockLists
321  * @tc.type: FUNC
322  * @tc.require: issueI8FCZA
323  */
324 HWTEST_F(PowerMgrServiceTest, PowerMgrService017, TestSize.Level2)
325 {
326     auto& powerMgrClient = PowerMgrClient::GetInstance();
327     std::map<std::string, RunningLockInfo> runningLockLists;
328     bool ret = powerMgrClient.QueryRunningLockLists(runningLockLists);
329     EXPECT_EQ(ret, true);
330     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService017 end.");
331 }
332 
333 /**
334  * @tc.name: PowerMgrService018
335  * @tc.desc: Test RunningLock Deconstructor unlock
336  * @tc.type: FUNC
337  */
338 HWTEST_F (PowerMgrServiceTest, PowerMgrService018, TestSize.Level0)
339 {
340     auto& powerMgrClient = PowerMgrClient::GetInstance();
341     auto runningLock1 = powerMgrClient.CreateRunningLock("runninglock1", RunningLockType::RUNNINGLOCK_SCREEN);
342     ASSERT_TRUE(runningLock1 != nullptr);
343     runningLock1->Lock();
344     ASSERT_TRUE(runningLock1->IsUsed()) << "runningLock1->IsUsed() != true";
345     runningLock1->UnLock();
346     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService018 end.");
347 }
348 
349 /**
350  * @tc.name: PowerMgrService019
351  * @tc.desc: Test Pre-light the screen.
352  * @tc.type: FUNC
353  */
354 HWTEST_F (PowerMgrServiceTest, PowerMgrService019, TestSize.Level0)
355 {
356     auto& powerMgrClient = PowerMgrClient::GetInstance();
357     powerMgrClient.SuspendDevice();
358     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
359 
360     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
361     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
362     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_success");
363     EXPECT_EQ(powerMgrClient.IsScreenOn(), true);
364 
365     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService019 end.");
366 }
367 
368 /**
369  * @tc.name: PowerMgrService020
370  * @tc.desc: Test if the authentication fails, the screen is on.
371  * @tc.type: FUNC
372  */
373 HWTEST_F (PowerMgrServiceTest, PowerMgrService020, TestSize.Level0)
374 {
375     auto& powerMgrClient = PowerMgrClient::GetInstance();
376     powerMgrClient.SuspendDevice();
377     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
378 
379     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
380     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
381     PowerErrors ret =
382         powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_fail_screen_on");
383     EXPECT_EQ(ret, PowerErrors::ERR_OK);
384 
385     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService020 end.");
386 }
387 
388 /**
389  * @tc.name: PowerMgrService021
390  * @tc.desc: Test if the authentication fails, the screen is off.
391  * @tc.type: FUNC
392  */
393 HWTEST_F (PowerMgrServiceTest, PowerMgrService021, TestSize.Level0)
394 {
395     auto& powerMgrClient = PowerMgrClient::GetInstance();
396     powerMgrClient.SuspendDevice();
397     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
398 
399     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
400     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
401     powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_fail_screen_off");
402     EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
403 
404     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService021 end.");
405 }
406 
407 /**
408  * @tc.name: PowerMgrService022
409  * @tc.desc: Test PowerMgrService LockScreenAfterTimingOut.
410  * @tc.type: FUNC
411  */
412 HWTEST_F (PowerMgrServiceTest, PowerMgrService022, TestSize.Level0)
413 {
414     auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
415     ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService022 fail to get PowerMgrService";
416     pmsTest_->OnStart();
417     auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
418     auto runningLockMgr = pmsTest_->GetRunningLockMgr();
419 
420     pmsTest_.GetRefPtr()->IncStrongRef(pmsTest_.GetRefPtr());
421     RunningLockParam runningLockParam;
422     runningLockParam.name = "runninglock_screen_on";
423     runningLockParam.type = RunningLockType::RUNNINGLOCK_SCREEN;
424     sptr<IRemoteObject> remoteObject = new RunningLockTokenStub();
425     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObject, runningLockParam) != nullptr);
426     runningLockMgr->Lock(remoteObject);
427 
428     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
429         StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
430     pmsTest_->LockScreenAfterTimingOut(true, false, true, nullptr);
431     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
432         StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
433     pmsTest_->LockScreenAfterTimingOut(false, false, true, nullptr);
434     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
435         StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK);
436     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY),
437         StateChangeReason::STATE_CHANGE_REASON_HARD_KEY);
438     pmsTest_->LockScreenAfterTimingOut(true, true, true, nullptr);
439     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
440         StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK);
441     runningLockMgr->UnLock(remoteObject);
442     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
443         StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
444     // wait runninglock async task to end, otherwise it will interfere with the next test case
445     pmsTest_->OnStop();
446     ffrt::wait();
447 }
448 
449 /**
450  * @tc.name: PowerMgrService023
451  * @tc.desc: Test transition to DIM state for Timeout.
452  * @tc.type: FUNC
453  */
454 HWTEST_F (PowerMgrServiceTest, PowerMgrService023, TestSize.Level0)
455 {
456     constexpr const int64_t screenOffTime = 4000;
457     constexpr const int64_t US_PER_MS = 1000;
458     constexpr const uint32_t DELAY_US = 500 * 1000;
459     auto& powerMgrClient = PowerMgrClient::GetInstance();
460     powerMgrClient.WakeupDevice();
461     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
462     EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(screenOffTime) == PowerErrors::ERR_OK);
463     // wait till going to DIM
464     usleep((screenOffTime - screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_WAIT_TIME_MS) * US_PER_MS);
465     EXPECT_EQ(powerMgrClient.GetState(), PowerState::DIM);
466     EXPECT_TRUE(powerMgrClient.RefreshActivity());
467     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
468     // wait till going to DIM
469     usleep((screenOffTime - screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_WAIT_TIME_MS) * US_PER_MS);
470     EXPECT_EQ(powerMgrClient.GetState(), PowerState::DIM);
471     // wait till going to SLEEP
472     usleep((screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_OFF_WAIT_TIME_MS) *
473         US_PER_MS);
474     usleep(DELAY_US);
475     EXPECT_EQ(powerMgrClient.GetState(), PowerState::SLEEP);
476     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService023 end.");
477 }
478 
479 /**
480  * @tc.name: PowerMgrService024
481  * @tc.desc: Test multithread refreshing.
482  * @tc.type: FUNC
483  */
484 HWTEST_F(PowerMgrServiceTest, PowerMgrService024, TestSize.Level0)
485 {
486     constexpr const uint32_t TESTING_DURATION_S = 10;
487     constexpr const uint32_t OPERATION_DELAY_US = 500 * 1000;
488     constexpr const uint32_t EXTREMELY_SHORT_SCREEN_OFF_TIME_MS = 200;
489     constexpr const uint32_t SHORT_SCREEN_OFF_TIME_MS = 800;
490     auto& powerMgrClient = PowerMgrClient::GetInstance();
491     powerMgrClient.OverrideScreenOffTime(SHORT_SCREEN_OFF_TIME_MS);
492     powerMgrClient.WakeupDevice();
493     EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
494     std::vector<std::thread> refreshThreads;
495     bool notified = false;
__anon699682c90202() 496     auto refreshTask = [&powerMgrClient, &notified]() {
497         while (!notified) {
498             powerMgrClient.RefreshActivity();
499         }
500     };
501 
502     for (int i = 0; i < 100; i++) {
503         refreshThreads.emplace_back(std::thread(refreshTask));
504     }
505 
__anon699682c90302() 506     auto checkingTask = [&powerMgrClient, &notified]() {
507         while (!notified) {
508             powerMgrClient.SuspendDevice();
509             usleep(OPERATION_DELAY_US);
510             EXPECT_EQ(powerMgrClient.GetState(), PowerState::SLEEP);
511             usleep(OPERATION_DELAY_US);
512             powerMgrClient.WakeupDevice();
513             EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
514             usleep(OPERATION_DELAY_US);
515         }
516     };
517     // checks whether refresh tasks may unexpectly turn screen on
518     std::thread checkingThread(checkingTask);
519     sleep(10);
520     notified = true;
521     for (auto& thread : refreshThreads) {
522         thread.join();
523     }
524     checkingThread.join();
525     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService024 end.");
526 }
527 
528 /**
529  * @tc.name: PowerMgrService025
530  * @tc.desc: Test StateChangeReason Get
531  * @tc.type: FUNC
532  */
533 HWTEST_F(PowerMgrServiceTest, PowerMgrService025, TestSize.Level2)
534 {
535     auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
536     ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService025 failed to get PowerMgrService";
537     pmsTest_->OnStart();
538     auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
539     ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService025 failed to get PowerStateMachine";
540 
541     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_LID),
542         StateChangeReason::STATE_CHANGE_REASON_LID);
543     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH),
544         StateChangeReason::STATE_CHANGE_REASON_SWITCH);
545     EXPECT_EQ(stateMaschine_->GetReasionBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY),
546         StateChangeReason::STATE_CHANGE_REASON_HARD_KEY);
547     EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_LID),
548         StateChangeReason::STATE_CHANGE_REASON_LID);
549     EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_SWITCH),
550         StateChangeReason::STATE_CHANGE_REASON_SWITCH);
551     EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON),
552         StateChangeReason::STATE_CHANGE_REASON_POWER_KEY);
553     EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL),
554         StateChangeReason::STATE_CHANGE_REASON_INCOMING_CALL);
555     EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_SHELL),
556         StateChangeReason::STATE_CHANGE_REASON_SHELL);
557     pmsTest_->OnStop();
558     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService025 end.");
559 }
560 
561 /**
562  * @tc.name: PowerMgrService026
563  * @tc.desc: Test ParseWakeupDeviceType
564  * @tc.type: FUNC
565  */
566 HWTEST_F(PowerMgrServiceTest, PowerMgrService026, TestSize.Level2)
567 {
568     auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
569     ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService026 failed to get PowerMgrService";
570     pmsTest_->OnStart();
571     auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
572     ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService026 failed to get PowerStateMachine";
573 
574     EXPECT_EQ(stateMaschine_->ParseWakeupDeviceType("incoming call"), WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL);
575     EXPECT_EQ(stateMaschine_->ParseWakeupDeviceType("shell"), WakeupDeviceType::WAKEUP_DEVICE_SHELL);
576     EXPECT_EQ(stateMaschine_->ParseWakeupDeviceType("pre_bright"), WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT);
577     EXPECT_EQ(stateMaschine_->ParseWakeupDeviceType("pre_bright_auth_success"),
578         WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS);
579     EXPECT_EQ(stateMaschine_->ParseWakeupDeviceType("pre_bright_auth_fail_screen_on"),
580         WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON);
581     EXPECT_EQ(stateMaschine_->ParseWakeupDeviceType("pre_bright_auth_fail_screen_off"),
582         WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF);
583 
584     pmsTest_->OnStop();
585     POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService026 end.");
586 }
587 }