1 /*
2 * Copyright (c) 2021-2024 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 "native_power_state_machine_test.h"
17
18 #include <ipc_skeleton.h>
19
20 #include "actions/irunning_lock_action.h"
21
22 using namespace testing::ext;
23 using namespace OHOS::PowerMgr;
24 using namespace OHOS;
25 using namespace std;
26
27 namespace {
28 OHOS::Rosen::FoldDisplayMode g_foldDisplayMode = OHOS::Rosen::FoldDisplayMode::MAIN;
29 } // namespace
30 namespace OHOS::Rosen {
GetFoldDisplayMode()31 FoldDisplayMode DisplayManagerLite::GetFoldDisplayMode()
32 {
33 return g_foldDisplayMode;
34 }
35
SetFoldDisplayMode(FoldDisplayMode mode)36 void DisplayManagerLite::SetFoldDisplayMode(FoldDisplayMode mode)
37 {
38 g_foldDisplayMode = mode;
39 }
40 } // namespace OHOS::Rosen
41
SetUpTestCase()42 void NativePowerStateMachineTest::SetUpTestCase() {}
43
OnPowerStateChanged(PowerState state)44 void PowerStateTest1Callback::OnPowerStateChanged(PowerState state)
45 {
46 POWER_HILOGI(
47 LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %{public}u.", static_cast<uint32_t>(state));
48 }
49
OnAsyncPowerStateChanged(PowerState state)50 void PowerStateTest1Callback::OnAsyncPowerStateChanged(PowerState state)
51 {
52 POWER_HILOGI(LABEL_TEST, "PowerStateTest1Callback::OnAsyncPowerStateChanged state = %{public}u.",
53 static_cast<uint32_t>(state));
54 }
55
OnPowerStateChanged(PowerState state)56 void PowerStateTest2Callback::OnPowerStateChanged(PowerState state)
57 {
58 POWER_HILOGI(
59 LABEL_TEST, "PowerStateTest2Callback::OnPowerStateChanged state = %{public}u.", static_cast<uint32_t>(state));
60 }
61
OnAsyncPowerStateChanged(PowerState state)62 void PowerStateTest2Callback::OnAsyncPowerStateChanged(PowerState state)
63 {
64 POWER_HILOGI(LABEL_TEST, "PowerStateTest2Callback::OnAsyncPowerStateChanged state = %{public}u.",
65 static_cast<uint32_t>(state));
66 }
67
68 namespace {
TransitResultToStateChangeReason(StateChangeReason trigger)69 TransitResult TransitResultToStateChangeReason(StateChangeReason trigger)
70 {
71 return TransitResult::ALREADY_IN_STATE;
72 }
73
74 /**
75 * @tc.name: NativePowerStateMachine001
76 * @tc.desc: test init in powerStateMachine
77 * @tc.type: FUNC
78 */
79 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine001, TestSize.Level1)
80 {
81 GTEST_LOG_(INFO) << "NativePowerStateMachine001: Suspend Device start.";
82 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine001 function start!");
83 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
84 pmsTest->OnStart();
85 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
86 EXPECT_TRUE(stateMachine->Init());
87 EXPECT_TRUE(stateMachine->Init());
88 stateMachine->InitState();
89 EXPECT_FALSE(stateMachine->CheckRefreshTime());
90 EXPECT_TRUE(stateMachine->CheckRefreshTime());
91 EXPECT_FALSE(stateMachine->RestoreScreenOffTimeInner());
92 EXPECT_TRUE(stateMachine->OverrideScreenOffTimeInner(TIMEOUT));
93 EXPECT_TRUE(stateMachine->OverrideScreenOffTimeInner(TIMEOUT));
94 stateMachine->SetDisplayOffTime(TIME, true);
95 stateMachine->ResetInactiveTimer();
96 std::string result;
97 stateMachine->DumpInfo(result);
98 EXPECT_TRUE(stateMachine->RestoreScreenOffTimeInner());
99 stateMachine->onWakeup();
100 stateMachine->SetSleepTime(TIME);
101 stateMachine->ResetSleepTimer();
102
103 bool ret = stateMachine->SetState(PowerState::UNKNOWN, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
104 EXPECT_FALSE(ret);
105 stateMachine->SetDisplaySuspend(true);
106 stateMachine->SetDisplaySuspend(false);
107
108 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine001 function end!");
109 GTEST_LOG_(INFO) << "NativePowerStateMachine001: Suspend Device end.";
110 }
111
112 /**
113 * @tc.name: NativePowerStateMachine002
114 * @tc.desc: test callback in powerStateMachine
115 * @tc.type: FUNC
116 */
117 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine002, TestSize.Level1)
118 {
119 GTEST_LOG_(INFO) << "NativePowerStateMachine002: Suspend Device start.";
120 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine002 function start!");
121 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
122 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
123 EXPECT_TRUE(stateMachine->Init());
124 stateMachine->ReceiveScreenEvent(true);
125 stateMachine->ReceiveScreenEvent(false);
126 sptr<IPowerStateCallback> callBackFirst = new PowerStateTest1Callback();
127 stateMachine->RegisterPowerStateCallback(callBackFirst);
128 stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
129 EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
130 stateMachine->UnRegisterPowerStateCallback(callBackFirst);
131 sptr<IPowerStateCallback> callBackSecond = new PowerStateTest2Callback();
132 stateMachine->RegisterPowerStateCallback(callBackSecond);
133 stateMachine->UnRegisterPowerStateCallback(callBackSecond);
134 sptr<IPowerStateCallback> callBackThird = nullptr;
135 stateMachine->RegisterPowerStateCallback(callBackThird);
136 stateMachine->UnRegisterPowerStateCallback(callBackThird);
137 stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT, true);
138 EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
139
140 sptr<IPowerStateCallback> callBackFourth = new PowerStateTest1Callback();
141 stateMachine->RegisterPowerStateCallback(callBackFourth, false);
142 stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
143 EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
144 stateMachine->UnRegisterPowerStateCallback(callBackFourth);
145 sptr<IPowerStateCallback> callBackFifth = new PowerStateTest2Callback();
146 sptr<IPowerStateCallback> callBackSixth = nullptr;
147 stateMachine->RegisterPowerStateCallback(callBackFifth, false);
148 stateMachine->RegisterPowerStateCallback(callBackSixth, false);
149 stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT, true);
150 EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
151 stateMachine->UnRegisterPowerStateCallback(callBackFifth);
152 stateMachine->UnRegisterPowerStateCallback(callBackSixth);
153 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine002 function end!");
154 GTEST_LOG_(INFO) << "NativePowerStateMachine002: Suspend Device end.";
155 }
156
157 /**
158 * @tc.name: NativePowerStateMachine003
159 * @tc.desc: test suspendDeviceInner in powerStateMachine
160 * @tc.type: FUNC
161 */
162 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine003, TestSize.Level1)
163 {
164 GTEST_LOG_(INFO) << "NativePowerStateMachine003: Suspend Device start.";
165 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine003 function start!");
166 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
167 pmsTest->OnStart();
168 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
169 EXPECT_TRUE(stateMachine->Init());
170 int32_t powermsEvent = PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG;
171 stateMachine->SetDelayTimer(stateMachine->GetDisplayOffTime() / THREE, powermsEvent);
172
173 SuspendDeviceType suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION;
174 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
175 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN;
176 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, true);
177 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT;
178 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
179 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_LID;
180 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
181 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_KEY;
182 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
183 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI;
184 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
185 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY;
186 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
187 suspendDeviceType = static_cast<SuspendDeviceType>(MAXTYPE);
188 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
189
190 stateMachine->RegisterDisplayOffTimeObserver();
191 stateMachine->RegisterDisplayOffTimeObserver();
192 stateMachine->UnregisterDisplayOffTimeObserver();
193 stateMachine->UnregisterDisplayOffTimeObserver();
194
195 std::string result;
196 stateMachine->DumpInfo(result);
197
198 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine003 function end!");
199 GTEST_LOG_(INFO) << "NativePowerStateMachine003: Suspend Device end.";
200 }
201
202 /**
203 * @tc.name: NativePowerStateMachine004
204 * @tc.desc: test refreshActivityInner and wakeupDeviceInner in powerMgrService
205 * @tc.type: FUNC
206 */
207 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine004, TestSize.Level1)
208 {
209 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine004 function start!");
210 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
211 UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_OTHER;
212 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
213 EXPECT_TRUE(stateMachine->Init());
214 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
215 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, static_cast<UserActivityType>(MAXTYPE), true);
216 bool ret = stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
217 EXPECT_TRUE(ret);
218 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
219 userActivityType = UserActivityType::USER_ACTIVITY_TYPE_TOUCH;
220 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
221 userActivityType = UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE;
222 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
223 userActivityType = UserActivityType::USER_ACTIVITY_TYPE_BUTTON;
224 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
225
226 WakeupDeviceType type = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION;
227 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
228 type = WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON;
229 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
230 type = WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY;
231 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
232 type = WakeupDeviceType::WAKEUP_DEVICE_HDMI;
233 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
234 type = WakeupDeviceType::WAKEUP_DEVICE_GESTURE;
235 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
236 type = WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH;
237 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
238 type = WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION;
239 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
240 type = WakeupDeviceType::WAKEUP_DEVICE_LID;
241 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
242 type = WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK;
243 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
244 type = WakeupDeviceType::WAKEUP_DEVICE_PEN;
245 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
246 type = WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD;
247 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
248 type = WakeupDeviceType::WAKEUP_DEVICE_MOUSE;
249 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
250 type = WakeupDeviceType::WAKEUP_DEVICE_PICKUP;
251 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
252
253 stateMachine->SetSwitchState(false);
254 type = WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN;
255 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
256 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, static_cast<WakeupDeviceType>(MAXTYPE), "7", "7");
257
258 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine004 function end!");
259 }
260
261 /**
262 * @tc.name: NativePowerStateMachine005
263 * @tc.desc: test recordFailure in powerStateMachine
264 * @tc.type: FUNC
265 */
266 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine005, TestSize.Level1)
267 {
268 GTEST_LOG_(INFO) << "NativePowerStateMachine005: Suspend Device start.";
269 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine005 function start!");
270 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
271
272 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
273 EXPECT_TRUE(stateMachine->Init());
274
275 auto stateMachineController = std::make_shared<PowerStateMachine::StateController>(
276 PowerState::INACTIVE, stateMachine, TransitResultToStateChangeReason);
277 StateChangeReason trigger = StateChangeReason::STATE_CHANGE_REASON_BATTERY;
278 TransitResult failReason = TransitResult::LOCKING;
279 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
280 failReason = TransitResult::HDI_ERR;
281 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
282 failReason = TransitResult::DISPLAY_ON_ERR;
283 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
284 failReason = TransitResult::DISPLAY_OFF_ERR;
285 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
286 failReason = TransitResult::OTHER_ERR;
287 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
288 #ifdef POWER_MANAGER_POWER_ENABLE_S4
289 EXPECT_TRUE(stateMachineController->TransitTo(trigger, false) == TransitResult::LOCKING);
290 #else
291 EXPECT_TRUE(stateMachineController->TransitTo(trigger, false) == TransitResult::ALREADY_IN_STATE);
292 #endif
293 stateMachine->SetDisplayOffTime(TIME, false);
294
295 auto stateMachineController2 = std::make_shared<PowerStateMachine::StateController>(
296 PowerState::INACTIVE, nullptr, TransitResultToStateChangeReason);
297 EXPECT_TRUE(stateMachineController2->TransitTo(trigger, false) == TransitResult::OTHER_ERR);
298 EXPECT_FALSE(stateMachineController2->CheckState());
299
300 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine005 function end!");
301 GTEST_LOG_(INFO) << "NativePowerStateMachine005: Suspend Device end.";
302 }
303
304 /**
305 * @tc.name: NativePowerStateMachine006
306 * @tc.desc: test recordFailure in powerStateMachine
307 * @tc.type: FUNC
308 */
309 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine006, TestSize.Level1)
310 {
311 GTEST_LOG_(INFO) << "NativePowerStateMachine006: Suspend Device start.";
312 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine006 function start!");
313 auto stateMachine = std::make_shared<PowerStateMachine>(nullptr);
314 EXPECT_TRUE(stateMachine->Init());
315 EXPECT_FALSE(stateMachine->CheckRunningLock(PowerState::INACTIVE));
316
317 auto stateMachineController = std::make_shared<PowerStateMachine::StateController>(
318 PowerState::INACTIVE, stateMachine, TransitResultToStateChangeReason);
319 StateChangeReason trigger = StateChangeReason::STATE_CHANGE_REASON_BATTERY;
320 EXPECT_TRUE(stateMachineController->TransitTo(trigger, false) == TransitResult::LOCKING);
321 stateMachine->currentState_ = PowerState::INACTIVE;
322 stateMachine->SetDisplaySuspend(false);
323 stateMachine->SetSleepTime(TIME);
324 SuspendDeviceType suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION;
325 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
326
327 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine006 function end!");
328 GTEST_LOG_(INFO) << "NativePowerStateMachine006: Suspend Device end.";
329 }
330
331 /**
332 * @tc.name: NativePowerStateMachine007
333 * @tc.desc: test init in powerStateMachine
334 * @tc.type: FUNC
335 */
336 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine007, TestSize.Level1)
337 {
338 GTEST_LOG_(INFO) << "NativePowerStateMachine007: Suspend Device start.";
339 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine007 function start!");
340 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
341 pmsTest->OnStart();
342 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
343 EXPECT_TRUE(stateMachine->Init());
344
345 bool ret = stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
346 EXPECT_TRUE(ret);
347 stateMachine->HandleSystemWakeup();
348 stateMachine->HandleActivitySleepTimeout();
349 ret = stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
350 EXPECT_TRUE(ret);
351 stateMachine->HandleSystemWakeup();
352
353 sptr<IRemoteObject> token = new RunningLockTokenStub();
354 RunningLockInfo infoInactive("test1", RunningLockType::RUNNINGLOCK_SCREEN);
355 pmsTest->CreateRunningLock(token, infoInactive);
356 pmsTest->Lock(token);
357 EXPECT_EQ(pmsTest->IsUsed(token), true);
358 stateMachine->HandleActivityTimeout();
359
360 pmsTest->UnLock(token);
361 EXPECT_EQ(pmsTest->IsUsed(token), false);
362
363 pmsTest->UnLock(token);
364 EXPECT_EQ(pmsTest->IsUsed(token), false);
365
366 ret = stateMachine->ReportScreenOffInvalidEvent(StateChangeReason::STATE_CHANGE_REASON_HARD_KEY);
367 EXPECT_TRUE(ret);
368 ret = stateMachine->ReportAbnormalScreenOffEvent(StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
369 EXPECT_TRUE(ret);
370 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine007 function end!");
371 GTEST_LOG_(INFO) << "NativePowerStateMachine007: Suspend Device end.";
372 }
373 /**
374 * @tc.name: NativePowerStateMachine008
375 * @tc.desc: test duration of DIM state
376 * @tc.type: FUNC
377 */
378 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine008, TestSize.Level1)
379 {
380 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine008 function start!");
381 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
382 pmsTest->OnStart();
383 auto stateMachine = pmsTest->GetPowerStateMachine();
384 stateMachine->OverrideScreenOffTimeInner(10 * 1000);
385 auto displayOffTime = stateMachine->GetDisplayOffTime();
386 EXPECT_EQ(displayOffTime, 10 * 1000);
387 EXPECT_EQ(stateMachine->GetDimTime(displayOffTime), displayOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR);
388
389 stateMachine->OverrideScreenOffTimeInner(60 * 1000);
390 displayOffTime = stateMachine->GetDisplayOffTime();
391 EXPECT_EQ(displayOffTime, 60 * 1000);
392 EXPECT_EQ(stateMachine->GetDimTime(displayOffTime), PowerStateMachine::MAX_DIM_TIME_MS);
393 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine008 function end!");
394 }
395
396 /**
397 * @tc.name: NativePowerStateMachine009
398 * @tc.desc: test GetExternalScreenNumber
399 * @tc.type: FUNC
400 */
401 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine009, TestSize.Level1)
402 {
403 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine009 function start!");
404 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
405 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
406 pmsTest->OnStart();
407 pmsTest->RegisterExternalScreenListener();
408 EXPECT_TRUE(pmsTest->externalScreenListener_ != nullptr);
409 auto stateMachine = pmsTest->GetPowerStateMachine();
410 constexpr uint64_t SCREEN_A_ID = 10001;
411 constexpr uint64_t SCREEN_B_ID = 10002;
412 pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
413 EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 1);
414 pmsTest->externalScreenListener_->OnConnect(SCREEN_B_ID);
415 EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 2);
416 pmsTest->externalScreenListener_->OnDisconnect(SCREEN_B_ID);
417 EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 1);
418 pmsTest->UnRegisterExternalScreenListener();
419 #endif
420 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine009 function end!");
421 }
422
423 /**
424 * @tc.name: NativePowerStateMachine010
425 * @tc.desc: test HandleDuringCallState
426 * @tc.type: FUNC
427 */
428 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine010, TestSize.Level1)
429 {
430 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine010 function start!");
431 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
432 pmsTest->OnStart();
433 pmsTest->SuspendControllerInit();
434 pmsTest->WakeupControllerInit();
435 auto stateMachine = pmsTest->GetPowerStateMachine();
436
437 EXPECT_TRUE(pmsTest->SuspendDevice(SUSCALLTIMEMS, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)
438 == PowerErrors::ERR_OK);
439 constexpr int ONE_SECOND = 1;
440 sleep(ONE_SECOND);
441 EXPECT_EQ(stateMachine->IsScreenOn(), false) << "NativePowerStateMachine010: Prepare Fail, Screen is On";
442 pmsTest->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "NativePowerStateMachine010");
443 sleep(ONE_SECOND);
444 EXPECT_EQ(stateMachine->IsScreenOn(), true) << "NativePowerStateMachine010: Prepare Fail, Screen is Off";
445 stateMachine->SetDuringCallState(true);
446
447 g_foldDisplayMode = OHOS::Rosen::FoldDisplayMode::MAIN;
448 bool ret = stateMachine->HandleDuringCall(true);
449 EXPECT_FALSE(g_foldDisplayMode == OHOS::Rosen::FoldDisplayMode::SUB && ret);
450 ret = stateMachine->HandleDuringCall(true);
451 EXPECT_FALSE(g_foldDisplayMode == OHOS::Rosen::FoldDisplayMode::SUB && ret);
452 ret = stateMachine->HandleDuringCall(false);
453 EXPECT_TRUE(g_foldDisplayMode == OHOS::Rosen::FoldDisplayMode::MAIN && ret);
454 ret = stateMachine->HandleDuringCall(false);
455 EXPECT_TRUE(g_foldDisplayMode == OHOS::Rosen::FoldDisplayMode::MAIN && ret);
456 g_foldDisplayMode = OHOS::Rosen::FoldDisplayMode::FULL;
457 ret = stateMachine->HandleDuringCall(true);
458 EXPECT_TRUE(g_foldDisplayMode == OHOS::Rosen::FoldDisplayMode::FULL && ret);
459
460 constexpr int WAIT_TIME_MS = 100;
461 usleep(WAIT_TIME_MS);
462 pmsTest->isDuringCallStateEnable_ = true;
463 g_foldDisplayMode = OHOS::Rosen::FoldDisplayMode::SUB;
464 ret = pmsTest->GetSuspendController()->NeedToSkipCurrentSuspend(
465 SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY, 0, 0);
466 EXPECT_TRUE(g_foldDisplayMode == OHOS::Rosen::FoldDisplayMode::MAIN && ret);
467 pmsTest->isDuringCallStateEnable_ = false;
468 pmsTest->GetSuspendController()->NeedToSkipCurrentSuspend(
469 SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY, 0, 0);
470 stateMachine->SetDuringCallState(false);
471 pmsTest->suspendController_ = nullptr;
472 EXPECT_TRUE(pmsTest->GetSuspendController() == nullptr);
473 usleep(WAIT_TIME_MS);
474 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine010 function end!");
475 }
476
477 /**
478 * @tc.name: NativePowerStateMachine011
479 * @tc.desc: test Lid Sensor
480 * @tc.type: FUNC
481 */
482 #ifdef HAS_SENSORS_SENSOR_PART
483 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine011, TestSize.Level0)
484 {
485 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine011 function start!");
486 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
487 pmsTest->OnStart();
488 pmsTest->SuspendControllerInit();
489 pmsTest->WakeupControllerInit();
490 SensorEvent event;
491 HallData data;
492 event.data = reinterpret_cast<uint8_t*>(&data);
493 event.sensorTypeId = SENSOR_TYPE_ID_HALL;
494 data.status = 0;
495 pmsTest->HallSensorCallback(&event);
496 data.status = 1;
497 pmsTest->HallSensorCallback(&event);
498 EXPECT_TRUE(pmsTest->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "NativePowerStateMachine011")
499 == PowerErrors::ERR_OK);
500 pmsTest->HallSensorCallback(&event);
501 data.status = 0;
502 pmsTest->HallSensorCallback(&event);
503 EXPECT_TRUE(pmsTest->SuspendDevice(SUSCALLTIMEMS, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)
504 == PowerErrors::ERR_OK);
505 pmsTest->HallSensorCallback(&event);
506 event.data = nullptr;
507 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine011 function end!");
508 }
509 #endif
510 } // namespace
511