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 
SetUpTestCase()27 void NativePowerStateMachineTest::SetUpTestCase() {}
28 
OnPowerStateChanged(PowerState state)29 void PowerStateTest1Callback::OnPowerStateChanged(PowerState state)
30 {
31     POWER_HILOGD(
32         LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %{public}u.", static_cast<uint32_t>(state));
33 }
34 
OnAsyncPowerStateChanged(PowerState state)35 void PowerStateTest1Callback::OnAsyncPowerStateChanged(PowerState state)
36 {
37     POWER_HILOGD(LABEL_TEST, "PowerStateTest1Callback::OnAsyncPowerStateChanged state = %{public}u.",
38         static_cast<uint32_t>(state));
39 }
40 
OnPowerStateChanged(PowerState state)41 void PowerStateTest2Callback::OnPowerStateChanged(PowerState state)
42 {
43     POWER_HILOGD(
44         LABEL_TEST, "PowerStateTest2Callback::OnPowerStateChanged state = %{public}u.", static_cast<uint32_t>(state));
45 }
46 
OnAsyncPowerStateChanged(PowerState state)47 void PowerStateTest2Callback::OnAsyncPowerStateChanged(PowerState state)
48 {
49     POWER_HILOGD(LABEL_TEST, "PowerStateTest2Callback::OnAsyncPowerStateChanged state = %{public}u.",
50         static_cast<uint32_t>(state));
51 }
52 
53 namespace {
TransitResultToStateChangeReason(StateChangeReason trigger)54 TransitResult TransitResultToStateChangeReason(StateChangeReason trigger)
55 {
56     return TransitResult::ALREADY_IN_STATE;
57 }
58 
59 /**
60  * @tc.name: NativePowerStateMachine001
61  * @tc.desc: test init in powerStateMachine
62  * @tc.type: FUNC
63  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine001, TestSize.Level0)64 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine001, TestSize.Level0)
65 {
66     GTEST_LOG_(INFO) << "NativePowerStateMachine001: Suspend Device start.";
67     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine001::fun is start!");
68     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
69     pmsTest->OnStart();
70     auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
71     EXPECT_TRUE(stateMachine->Init());
72     EXPECT_TRUE(stateMachine->Init());
73     stateMachine->InitState();
74     EXPECT_FALSE(stateMachine->CheckRefreshTime());
75     EXPECT_TRUE(stateMachine->CheckRefreshTime());
76     EXPECT_FALSE(stateMachine->RestoreScreenOffTimeInner());
77     EXPECT_TRUE(stateMachine->OverrideScreenOffTimeInner(TIMEOUT));
78     EXPECT_TRUE(stateMachine->OverrideScreenOffTimeInner(TIMEOUT));
79     stateMachine->SetDisplayOffTime(TIME, true);
80     stateMachine->ResetInactiveTimer();
81     std::string result;
82     stateMachine->DumpInfo(result);
83     EXPECT_TRUE(stateMachine->RestoreScreenOffTimeInner());
84     stateMachine->onWakeup();
85     stateMachine->SetSleepTime(TIME);
86     stateMachine->ResetSleepTimer();
87 
88     bool ret = stateMachine->SetState(PowerState::UNKNOWN, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
89     EXPECT_FALSE(ret);
90     stateMachine->SetDisplaySuspend(true);
91     stateMachine->SetDisplaySuspend(false);
92 
93     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine001::fun is end!");
94     GTEST_LOG_(INFO) << "NativePowerStateMachine001: Suspend Device end.";
95 }
96 
97 /**
98  * @tc.name: NativePowerStateMachine002
99  * @tc.desc: test callback in powerStateMachine
100  * @tc.type: FUNC
101  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine002, TestSize.Level0)102 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine002, TestSize.Level0)
103 {
104     GTEST_LOG_(INFO) << "NativePowerStateMachine002: Suspend Device start.";
105     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine002::fun is start!");
106     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
107     auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
108     EXPECT_TRUE(stateMachine->Init());
109     stateMachine->ReceiveScreenEvent(true);
110     stateMachine->ReceiveScreenEvent(false);
111     sptr<IPowerStateCallback> cb = new PowerStateTest1Callback();
112     stateMachine->RegisterPowerStateCallback(cb);
113     stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
114     EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
115     stateMachine->UnRegisterPowerStateCallback(cb);
116     sptr<IPowerStateCallback> cb1 = new PowerStateTest2Callback();
117     stateMachine->RegisterPowerStateCallback(cb1);
118     stateMachine->UnRegisterPowerStateCallback(cb1);
119     sptr<IPowerStateCallback> cb2 = nullptr;
120     stateMachine->RegisterPowerStateCallback(cb2);
121     stateMachine->UnRegisterPowerStateCallback(cb2);
122     stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT, true);
123     EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
124 
125     sptr<IPowerStateCallback> cb3 = new PowerStateTest1Callback();
126     stateMachine->RegisterPowerStateCallback(cb3, false);
127     stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
128     EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
129     stateMachine->UnRegisterPowerStateCallback(cb3);
130     sptr<IPowerStateCallback> cb4 = new PowerStateTest2Callback();
131     sptr<IPowerStateCallback> cb5 = nullptr;
132     stateMachine->RegisterPowerStateCallback(cb4, false);
133     stateMachine->RegisterPowerStateCallback(cb5, false);
134     stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT, true);
135     EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
136     stateMachine->UnRegisterPowerStateCallback(cb4);
137     stateMachine->UnRegisterPowerStateCallback(cb5);
138     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine002::fun is end!");
139     GTEST_LOG_(INFO) << "NativePowerStateMachine002: Suspend Device end.";
140 }
141 
142 /**
143  * @tc.name: NativePowerStateMachine003
144  * @tc.desc: test suspendDeviceInner in powerStateMachine
145  * @tc.type: FUNC
146  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine003, TestSize.Level0)147 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine003, TestSize.Level0)
148 {
149     GTEST_LOG_(INFO) << "NativePowerStateMachine003: Suspend Device start.";
150     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine003::fun is start!");
151     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
152     pmsTest->OnStart();
153     auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
154     EXPECT_TRUE(stateMachine->Init());
155     int32_t powermsEvent = PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG;
156     stateMachine->SetDelayTimer(stateMachine->GetDisplayOffTime() / THREE, powermsEvent);
157 
158     SuspendDeviceType suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION;
159     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
160     suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN;
161     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, true);
162     suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT;
163     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
164     suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_LID;
165     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
166     suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_KEY;
167     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
168     suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI;
169     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
170     suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY;
171     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
172     suspendDeviceType = static_cast<SuspendDeviceType>(MAXTYPE);
173     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
174 
175     stateMachine->RegisterDisplayOffTimeObserver();
176     stateMachine->RegisterDisplayOffTimeObserver();
177     stateMachine->UnregisterDisplayOffTimeObserver();
178     stateMachine->UnregisterDisplayOffTimeObserver();
179 
180     std::string result;
181     stateMachine->DumpInfo(result);
182 
183     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine003::fun is end!");
184     GTEST_LOG_(INFO) << "NativePowerStateMachine003: Suspend Device end.";
185 }
186 
187 /**
188  * @tc.name: NativePowerStateMachine004
189  * @tc.desc: test refreshActivityInner and wakeupDeviceInner in powerMgrService
190  * @tc.type: FUNC
191  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine004, TestSize.Level0)192 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine004, TestSize.Level0)
193 {
194     GTEST_LOG_(INFO) << "NativePowerStateMachine004: Suspend Device start.";
195     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine004::fun is start!");
196     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
197     UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_OTHER;
198     auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
199     EXPECT_TRUE(stateMachine->Init());
200     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
201     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, static_cast<UserActivityType>(MAXTYPE), true);
202     bool ret = stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
203     EXPECT_TRUE(ret);
204     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
205     userActivityType = UserActivityType::USER_ACTIVITY_TYPE_TOUCH;
206     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
207     userActivityType = UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE;
208     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
209     userActivityType = UserActivityType::USER_ACTIVITY_TYPE_BUTTON;
210     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
211 
212     WakeupDeviceType type = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION;
213     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
214     type = WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON;
215     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
216     type = WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY;
217     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
218     type = WakeupDeviceType::WAKEUP_DEVICE_HDMI;
219     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
220     type = WakeupDeviceType::WAKEUP_DEVICE_GESTURE;
221     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
222     type = WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH;
223     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
224     type = WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION;
225     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
226     type = WakeupDeviceType::WAKEUP_DEVICE_LID;
227     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
228     type = WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK;
229     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
230     type = WakeupDeviceType::WAKEUP_DEVICE_PEN;
231     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
232     type = WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD;
233     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
234     type = WakeupDeviceType::WAKEUP_DEVICE_MOUSE;
235     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
236     type = WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN;
237     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
238     stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, static_cast<WakeupDeviceType>(MAXTYPE), "7", "7");
239 
240     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine004::fun is end!");
241     GTEST_LOG_(INFO) << "NativePowerStateMachine004: Suspend Device end.";
242 }
243 
244 /**
245  * @tc.name: NativePowerStateMachine005
246  * @tc.desc: test recordFailure in powerStateMachine
247  * @tc.type: FUNC
248  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine005, TestSize.Level0)249 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine005, TestSize.Level0)
250 {
251     GTEST_LOG_(INFO) << "NativePowerStateMachine005: Suspend Device start.";
252     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine005::fun is start!");
253     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
254 
255     auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
256     EXPECT_TRUE(stateMachine->Init());
257 
258     auto stateMachineController = std::make_shared<PowerStateMachine::StateController>(
259         PowerState::INACTIVE, stateMachine, TransitResultToStateChangeReason);
260     StateChangeReason trigger = StateChangeReason::STATE_CHANGE_REASON_BATTERY;
261     TransitResult failReason = TransitResult::LOCKING;
262     stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
263     failReason = TransitResult::HDI_ERR;
264     stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
265     failReason = TransitResult::DISPLAY_ON_ERR;
266     stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
267     failReason = TransitResult::DISPLAY_OFF_ERR;
268     stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
269     failReason = TransitResult::OTHER_ERR;
270     stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
271 
272     EXPECT_TRUE(stateMachineController->TransitTo(trigger, false) == TransitResult::ALREADY_IN_STATE);
273     stateMachine->SetDisplayOffTime(TIME, false);
274 
275     auto stateMachineController2 = std::make_shared<PowerStateMachine::StateController>(
276         PowerState::INACTIVE, nullptr, TransitResultToStateChangeReason);
277     EXPECT_TRUE(stateMachineController2->TransitTo(trigger, false) == TransitResult::OTHER_ERR);
278     EXPECT_FALSE(stateMachineController2->CheckState());
279 
280     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine005::fun is end!");
281     GTEST_LOG_(INFO) << "NativePowerStateMachine005: Suspend Device end.";
282 }
283 
284 /**
285  * @tc.name: NativePowerStateMachine006
286  * @tc.desc: test recordFailure in powerStateMachine
287  * @tc.type: FUNC
288  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine006, TestSize.Level0)289 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine006, TestSize.Level0)
290 {
291     GTEST_LOG_(INFO) << "NativePowerStateMachine006: Suspend Device start.";
292     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine006::fun is start!");
293     auto stateMachine = std::make_shared<PowerStateMachine>(nullptr);
294     EXPECT_TRUE(stateMachine->Init());
295     EXPECT_FALSE(stateMachine->CheckRunningLock(PowerState::INACTIVE));
296 
297     auto stateMachineController = std::make_shared<PowerStateMachine::StateController>(
298         PowerState::INACTIVE, stateMachine, TransitResultToStateChangeReason);
299     StateChangeReason trigger = StateChangeReason::STATE_CHANGE_REASON_BATTERY;
300     EXPECT_TRUE(stateMachineController->TransitTo(trigger, false) == TransitResult::LOCKING);
301     stateMachine->currentState_ = PowerState::INACTIVE;
302     stateMachine->SetDisplaySuspend(false);
303     stateMachine->SetSleepTime(TIME);
304     SuspendDeviceType suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION;
305     stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
306 
307     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine006::fun is end!");
308     GTEST_LOG_(INFO) << "NativePowerStateMachine006: Suspend Device end.";
309 }
310 
311 /**
312  * @tc.name: NativePowerStateMachine007
313  * @tc.desc: test init in powerStateMachine
314  * @tc.type: FUNC
315  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine007, TestSize.Level0)316 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine007, TestSize.Level0)
317 {
318     GTEST_LOG_(INFO) << "NativePowerStateMachine007: Suspend Device start.";
319     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine007::fun is start!");
320     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
321     pmsTest->OnStart();
322     auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
323     EXPECT_TRUE(stateMachine->Init());
324 
325     bool ret = stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
326     EXPECT_TRUE(ret);
327     stateMachine->HandleSystemWakeup();
328     stateMachine->HandleActivitySleepTimeout();
329     ret = stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
330     EXPECT_TRUE(ret);
331     stateMachine->HandleSystemWakeup();
332 
333     sptr<IRemoteObject> token = new RunningLockTokenStub();
334     RunningLockInfo infoInactive("test1", RunningLockType::RUNNINGLOCK_SCREEN);
335     pmsTest->CreateRunningLock(token, infoInactive);
336     pmsTest->Lock(token);
337     EXPECT_EQ(pmsTest->IsUsed(token), true);
338     stateMachine->HandleActivityTimeout();
339 
340     pmsTest->UnLock(token);
341     EXPECT_EQ(pmsTest->IsUsed(token), false);
342 
343     pmsTest->UnLock(token);
344     EXPECT_EQ(pmsTest->IsUsed(token), false);
345     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine007::fun is end!");
346     GTEST_LOG_(INFO) << "NativePowerStateMachine007: Suspend Device end.";
347 }
348 /**
349  * @tc.name: NativePowerStateMachine008
350  * @tc.desc: test duration of DIM state
351  * @tc.type: FUNC
352  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine008, TestSize.Level0)353 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine008, TestSize.Level0)
354 {
355     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine008: func started!");
356     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
357     pmsTest->OnStart();
358     auto stateMachine = pmsTest->GetPowerStateMachine();
359     stateMachine->OverrideScreenOffTimeInner(10 * 1000);
360     auto displayOffTime = stateMachine->GetDisplayOffTime();
361     EXPECT_EQ(displayOffTime, 10 * 1000);
362     EXPECT_EQ(stateMachine->GetDimTime(displayOffTime), displayOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR);
363 
364     stateMachine->OverrideScreenOffTimeInner(60 * 1000);
365     displayOffTime = stateMachine->GetDisplayOffTime();
366     EXPECT_EQ(displayOffTime, 60 * 1000);
367     EXPECT_EQ(stateMachine->GetDimTime(displayOffTime), PowerStateMachine::MAX_DIM_TIME_MS);
368 
369     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine008: func ended!");
370 }
371 
372 /**
373  * @tc.name: NativePowerStateMachine009
374  * @tc.desc: test GetExternalScreenNumber
375  * @tc.type: FUNC
376  */
HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine009, TestSize.Level0)377 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine009, TestSize.Level0)
378 {
379     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine009: func started!");
380 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
381     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
382     pmsTest->OnStart();
383     pmsTest->RegisterExternalScreenListener();
384     EXPECT_TRUE(pmsTest->externalScreenListener_ != nullptr);
385     auto stateMachine = pmsTest->GetPowerStateMachine();
386     constexpr uint64_t SCREEN_A_ID = 10001;
387     constexpr uint64_t SCREEN_B_ID = 10002;
388     pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
389     EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 1);
390     pmsTest->externalScreenListener_->OnConnect(SCREEN_B_ID);
391     EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 2);
392     pmsTest->externalScreenListener_->OnDisconnect(SCREEN_B_ID);
393     EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 1);
394     pmsTest->UnRegisterExternalScreenListener();
395 #endif
396     POWER_HILOGD(LABEL_TEST, "NativePowerStateMachine009: func ended!");
397 }
398 
399 } // namespace
400