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 "power_mgr_service_native_test.h"
17 
18 #ifdef THERMAL_GTEST
19 #define private   public
20 #define protected public
21 #endif
22 
23 #include <csignal>
24 #include <iostream>
25 
26 #include "key_event.h"
27 #include "pointer_event.h"
28 #include "power_common.h"
29 #include "power_mgr_service.h"
30 #include "setting_helper.h"
31 using namespace testing::ext;
32 using namespace OHOS::PowerMgr;
33 using namespace OHOS;
34 using namespace std;
35 
36 namespace {
37 constexpr int32_t TIMEOUTMS = 7;
38 constexpr int64_t CALLTIMEMS = 1;
39 constexpr int64_t SUSCALLTIMEMS = 3;
40 constexpr pid_t PID = 1;
41 constexpr pid_t UID = 1;
42 constexpr int32_t UNCANCELID = -1;
43 constexpr int32_t INVALID_CODE = -1;
44 sptr<PowerMgrService> g_pmsTest;
45 } // namespace
46 
SetUp()47 void PowerMgrServiceNativeTest::SetUp()
48 {
49     g_pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
50     EXPECT_TRUE(g_pmsTest != nullptr) << "PowerMgrService02 fail to get PowerMgrService";
51     g_pmsTest->OnStart();
52 
53     auto stateMachine = std::make_shared<PowerStateMachine>(g_pmsTest);
54     EXPECT_TRUE(stateMachine->Init());
55     UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY;
56     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
57     auto runningLockMgr = std::make_shared<RunningLockMgr>(g_pmsTest);
58     EXPECT_TRUE(runningLockMgr->Init());
59     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
60     RunningLockParam runningLockParam {0,
61         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, PID, UID};
62     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
63     runningLockMgr->Lock(remoteObj);
64     runningLockMgr->UnLock(remoteObj);
65     EXPECT_FALSE(runningLockMgr->ReleaseLock(remoteObj));
66 }
67 
TearDown()68 void PowerMgrServiceNativeTest::TearDown()
69 {
70     g_pmsTest->OnStop();
71 }
72 
OnPowerStateChanged(PowerState state)73 void PowerStateTestCallback::OnPowerStateChanged(PowerState state)
74 {
75     POWER_HILOGD(
76         LABEL_TEST, "PowerStateTestCallback::OnPowerStateChanged state = %{public}u.", static_cast<uint32_t>(state));
77 }
78 
79 namespace {
80 /**
81  * @tc.name: PowerMgrServiceNative001
82  * @tc.desc: test init in powerMgrService
83  * @tc.type: FUNC
84  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative001, TestSize.Level0)85 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative001, TestSize.Level0)
86 {
87     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative001 begin.");
88     g_pmsTest->HallSensorSubscriberInit();
89     g_pmsTest->HallSensorSubscriberCancel();
90 
91     int32_t keyCode = OHOS::MMI::KeyEvent::KEYCODE_F1;
92     g_pmsTest->HandleKeyEvent(keyCode);
93     int32_t type = OHOS::MMI::PointerEvent::SOURCE_TYPE_MOUSE;
94     g_pmsTest->HandlePointEvent(type);
95 
96     EXPECT_EQ(g_pmsTest->OverrideScreenOffTime(TIMEOUTMS), PowerErrors::ERR_OK);
97     EXPECT_EQ(g_pmsTest->RestoreScreenOffTime(), PowerErrors::ERR_OK);
98 
99     g_pmsTest->doubleClickId_ = UNCANCELID;
100     g_pmsTest->monitorId_ = UNCANCELID;
101     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative001 end.");
102 }
103 
104 /**
105  * @tc.name: PowerMgrServiceNative002
106  * @tc.desc: test handleKeyEvent in powerMgrService
107  * @tc.type: FUNC
108  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative002, TestSize.Level0)109 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative002, TestSize.Level0)
110 {
111     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative002 begin.");
112     int32_t keyCode = OHOS::MMI::KeyEvent::KEYCODE_F1;
113     g_pmsTest->HandleKeyEvent(keyCode);
114     keyCode = OHOS::MMI::KeyEvent::KEYCODE_F2;
115     g_pmsTest->HandleKeyEvent(keyCode);
116     keyCode = OHOS::MMI::KeyEvent::KEYCODE_VIRTUAL_MULTITASK;
117     g_pmsTest->HandleKeyEvent(keyCode);
118     keyCode = OHOS::MMI::KeyEvent::KEYCODE_WEAR_1;
119     g_pmsTest->HandleKeyEvent(keyCode);
120     int32_t type = OHOS::MMI::PointerEvent::SOURCE_TYPE_MOUSE;
121     g_pmsTest->HandlePointEvent(type);
122     type = OHOS::MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
123     g_pmsTest->HandlePointEvent(type);
124 
125     EXPECT_TRUE(g_pmsTest->ShutDownDevice(SHUTDOWN_FAST_REASON) == PowerErrors::ERR_OK);
126     SuspendDeviceType reasonSDT = SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN;
127     EXPECT_TRUE(g_pmsTest->SuspendDevice(SUSCALLTIMEMS, reasonSDT, false) == PowerErrors::ERR_OK);
128     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative002 end.");
129 }
130 
131 /**
132  * @tc.name: PowerMgrServiceNative003
133  * @tc.desc: test pickup register
134  * @tc.type: FUNC
135  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative003, TestSize.Level0)136 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative003, TestSize.Level0)
137 {
138     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative003 begin.");
139 #ifdef POWER_PICKUP_ENABLE
140     g_pmsTest->RegisterSettingWakeupPickupGestureObserver();
141     g_pmsTest->RegisterSettingWakeupPickupGestureObserver();
142     EXPECT_TRUE(SettingHelper::pickUpObserver_ != nullptr);
143     SettingHelper::UnregisterSettingWakeupPickupObserver();
144     SettingHelper::UnregisterSettingWakeupPickupObserver();
145     EXPECT_TRUE(SettingHelper::pickUpObserver_ == nullptr);
146 #endif
147     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative003 end.");
148 }
149 
150 /**
151  * @tc.name: PowerMgrServiceNative004
152  * @tc.desc: test autobrightness register
153  * @tc.type: FUNC
154  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative004, TestSize.Level0)155 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative004, TestSize.Level0)
156 {
157     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative004 begin.");
158     shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
159     EXPECT_TRUE(powerModeModuleTest != nullptr);
160     auto flag = SettingHelper::IsAutoAdjustBrightnessSettingValid();
161     powerModeModuleTest->RegisterAutoAdjustBrightnessObserver();
162     SettingHelper::SetSettingAutoAdjustBrightness(SettingHelper::SwitchStatus::INVALID);
163     auto ret = SettingHelper::GetSettingAutoAdjustBrightness(INVALID_CODE);
164     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative004 end.");
165 }
166 
167 /**
168  * @tc.name: PowerMgrServiceNative005
169  * @tc.desc: test brightness register
170  * @tc.type: FUNC
171  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative005, TestSize.Level0)172 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative005, TestSize.Level0)
173 {
174     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative005 begin.");
175     shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
176     EXPECT_TRUE(powerModeModuleTest != nullptr);
177     powerModeModuleTest->RegisterAutoAdjustBrightnessObserver();
178     auto flag = SettingHelper::IsBrightnessSettingValid();
179     SettingHelper::SetSettingBrightness(INVALID_CODE);
180     auto ret = SettingHelper::GetSettingAutoAdjustBrightness(INVALID_CODE);
181     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative005 end.");
182 }
183 
184 /**
185  * @tc.name: PowerMgrServiceNative006
186  * @tc.desc: test vibrateState register
187  * @tc.type: FUNC
188  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative006, TestSize.Level0)189 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative006, TestSize.Level0)
190 {
191     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative006 begin.");
192     shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
193     EXPECT_TRUE(powerModeModuleTest != nullptr);
194     powerModeModuleTest->RegisterVibrateStateObserver();
195     auto flag = SettingHelper::IsVibrationSettingValid();
196     SettingHelper::SetSettingVibration(SettingHelper::SwitchStatus::INVALID);
197     auto ret = SettingHelper::GetSettingVibration(INVALID_CODE);
198     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative006 end.");
199 }
200 
201 
202 /**
203  * @tc.name: PowerMgrServiceNative007
204  * @tc.desc: test autoWindowRotation register
205  * @tc.type: FUNC
206  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative007, TestSize.Level0)207 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative007, TestSize.Level0)
208 {
209     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative007 begin.");
210     shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
211     EXPECT_TRUE(powerModeModuleTest != nullptr);
212     powerModeModuleTest->RegisterAutoWindowRotationObserver();
213     auto flag = SettingHelper::IsWindowRotationSettingValid();
214     SettingHelper::SetSettingWindowRotation(SettingHelper::SwitchStatus::INVALID);
215     auto ret = SettingHelper::GetSettingWindowRotation(INVALID_CODE);
216     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative007 end.");
217 }
218 
219 /**
220  * @tc.name: PowerMgrServiceNative008
221  * @tc.desc: test intellVoiceSetting register
222  * @tc.type: FUNC
223  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative008, TestSize.Level0)224 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative008, TestSize.Level0)
225 {
226     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative008 begin.");
227     shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
228     EXPECT_TRUE(powerModeModuleTest != nullptr);
229     powerModeModuleTest->RegisterIntellVoiceObserver();
230     auto flag = SettingHelper::IsIntellVoiceSettingValid();
231     SettingHelper::SetSettingIntellVoice(SettingHelper::SwitchStatus::INVALID);
232     auto ret = SettingHelper::GetSettingIntellVoice(INVALID_CODE);
233     powerModeModuleTest->UnregisterSaveModeObserver();
234     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative008 end.");
235 }
236 
237 /**
238  * @tc.name: PowerMgrServiceNative009
239  * @tc.desc: test settingPowerMode register
240  * @tc.type: FUNC
241  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative009, TestSize.Level0)242 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative009, TestSize.Level0)
243 {
244     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative009 begin.");
245     g_pmsTest->RegisterSettingPowerModeObservers();
246     g_pmsTest->RegisterSettingPowerModeObservers();
247     EXPECT_TRUE(SettingHelper::powerModeObserver_ != nullptr);
248     SettingHelper::SaveCurrentMode(INVALID_CODE);
249     SettingHelper::UnRegisterSettingPowerModeObserver();
250     EXPECT_TRUE(SettingHelper::powerModeObserver_ == nullptr);
251     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative009 end.");
252 }
253 
254 /**
255  * @tc.name: PowerMgrServiceNative010
256  * @tc.desc: test settingWakeUpLid register
257  * @tc.type: FUNC
258  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative010, TestSize.Level0)259 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative010, TestSize.Level0)
260 {
261     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative010 begin.");
262     g_pmsTest->RegisterSettingWakeUpLidObserver();
263     SettingHelper::SetSettingWakeupLid(true);
264     bool ret = SettingHelper::GetSettingWakeupLid();
265     SettingHelper::UnRegisterSettingWakeupLidObserver();
266     EXPECT_TRUE(SettingHelper::lidObserver_ == nullptr);
267     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative010 end.");
268 }
269 
270 /**
271  * @tc.name: PowerMgrServiceNative011
272  * @tc.desc: test RegisterSettingWakeupDoubleClickObservers
273  * @tc.type: FUNC
274  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative011, TestSize.Level0)275 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative011, TestSize.Level0)
276 {
277     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative011 begin.");
278 #ifdef POWER_DOUBLECLICK_ENABLE
279     g_pmsTest->RegisterSettingWakeupDoubleClickObservers();
280     g_pmsTest->RegisterSettingWakeupDoubleClickObservers();
281     SettingHelper::IsWakeupDoubleSettingValid();
282     SettingHelper::UnregisterSettingWakeupDoubleObserver();
283     SettingHelper::UnregisterSettingWakeupDoubleObserver();
284     EXPECT_TRUE(SettingHelper::doubleClickObserver_ == nullptr);
285 #endif
286     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative011 end.");
287 }
288 
289 /**
290  * @tc.name: PowerMgrServiceNative012
291  * @tc.desc: test RegisterMovementCallback
292  * @tc.type: FUNC
293  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative012, TestSize.Level0)294 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative012, TestSize.Level0)
295 {
296     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative012 begin.");
297 #ifdef MSDP_MOVEMENT_ENABLE
298     auto stateMachine = std::make_shared<PowerStateMachine>(g_pmsTest);
299     g_pmsTest->RegisterMovementCallback();
300     g_pmsTest->UnRegisterMovementCallback();
301     g_pmsTest->ResetMovementState();
302     bool ret =  stateMachine->IsMovementStateOn();
303     EXPECT_TRUE(ret == false);
304 #endif
305     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative012 end.");
306 }
307 
308 /**
309  * @tc.name: PowerMgrServiceNative013
310  * @tc.desc: test RegisterExternalScreenListener
311  * @tc.type: FUNC
312  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative013, TestSize.Level0)313 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative013, TestSize.Level0)
314 {
315     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative013 begin.");
316 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
317     g_pmsTest->RegisterExternalScreenListener();
318     EXPECT_TRUE(g_pmsTest->externalScreenListener_ != nullptr);
319     g_pmsTest->UnRegisterExternalScreenListener();
320     EXPECT_TRUE(g_pmsTest->externalScreenListener_ == nullptr);
321 #endif
322     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative013 end.");
323 }
324 
325 /**
326  * @tc.name: PowerMgrServiceNative014
327  * @tc.desc: test ExternalScreenListener OnConnect
328  * @tc.type: FUNC
329  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative014, TestSize.Level0)330 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative014, TestSize.Level0)
331 {
332     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative014 begin.");
333 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
334     g_pmsTest->SuspendControllerInit();
335     g_pmsTest->WakeupControllerInit();
336     // Register screen listener
337     g_pmsTest->RegisterExternalScreenListener();
338     EXPECT_TRUE(g_pmsTest->externalScreenListener_ != nullptr);
339 
340     auto powerStateMachine = g_pmsTest->GetPowerStateMachine();
341     constexpr uint64_t SCREEN_A_ID = 10001;
342     // Mock open switch to wakeup deivce
343     // case 1: isSwitchOpen:true, isScreenOn:true
344     powerStateMachine->SetSwitchState(true);
345     g_pmsTest->WakeupDevice(
346         static_cast<int64_t>(time(nullptr)), WakeupDeviceType::WAKEUP_DEVICE_SWITCH, "PowerMgrServiceNative014");
347     EXPECT_TRUE(powerStateMachine->IsScreenOn());
348     g_pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
349     EXPECT_TRUE(powerStateMachine->IsScreenOn());
350     powerStateMachine->DecreaseExternalScreenNumber();
351     EXPECT_EQ(powerStateMachine->GetExternalScreenNumber(), 0);
352 
353     // case 2: isSwitchOpen:true, isScreenOn:false
354     g_pmsTest->SuspendDevice(GetTickCount(), SuspendDevice::SUSPEND_DEVICE_REASON_POWER_KEY, false);
355     EXPECT_FALSE(powerStateMachine->IsScreenOn());
356     g_pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
357     EXPECT_TRUE(powerStateMachine->IsScreenOn());
358     powerStateMachine->DecreaseExternalScreenNumber();
359     EXPECT_EQ(powerStateMachine->GetExternalScreenNumber(), 0);
360 
361     // case 3: isSwitchOpen:false, isScreenOn:false
362     powerStateMachine->SetSwitchState(false);
363     g_pmsTest->SuspendDevice(GetTickCount(), SuspendDevice::SUSPEND_DEVICE_REASON_SWITCH, false);
364     EXPECT_FALSE(powerStateMachine->IsScreenOn());
365     g_pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
366     EXPECT_FALSE(powerStateMachine->IsScreenOn());
367     powerStateMachine->DecreaseExternalScreenNumber();
368     EXPECT_EQ(powerStateMachine->GetExternalScreenNumber(), 0);
369 
370     // Unregister screen listener
371     g_pmsTest->UnRegisterExternalScreenListener();
372     EXPECT_TRUE(g_pmsTest->externalScreenListener_ == nullptr);
373 #endif
374     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative014 end.");
375 }
376 
377 /**
378  * @tc.name: PowerMgrServiceNative015
379  * @tc.desc: test ExternalScreenListener OnDisconnect
380  * @tc.type: FUNC
381  */
HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative015, TestSize.Level0)382 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative015, TestSize.Level0)
383 {
384     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative015 begin.");
385 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
386     g_pmsTest->SuspendControllerInit();
387     g_pmsTest->WakeupControllerInit();
388     // Register screen listener
389     g_pmsTest->RegisterExternalScreenListener();
390     EXPECT_TRUE(g_pmsTest->externalScreenListener_ != nullptr);
391 
392     auto powerStateMachine = g_pmsTest->GetPowerStateMachine();
393     constexpr uint64_t SCREEN_A_ID = 10001;
394     // Mock open switch to wakeup deivce
395     // case 1: isSwitchOpen:true, isScreenOn:true
396     powerStateMachine->SetSwitchState(true);
397     g_pmsTest->WakeupDevice(
398         static_cast<int64_t>(time(nullptr)), WakeupDeviceType::WAKEUP_DEVICE_SWITCH, "PowerMgrServiceNative015");
399     powerStateMachine->IncreaseExternalScreenNumber();
400     EXPECT_EQ(powerStateMachine->GetExternalScreenNumber(), 1);
401     EXPECT_TRUE(powerStateMachine->IsScreenOn());
402     g_pmsTest->externalScreenListener_->OnDisconnect(SCREEN_A_ID);
403     EXPECT_TRUE(powerStateMachine->IsScreenOn());
404 
405     // case 2: isSwitchOpen:true, isScreenOn:false
406     g_pmsTest->SuspendDevice(GetTickCount(), SuspendDevice::SUSPEND_DEVICE_REASON_POWER_KEY, false);
407     EXPECT_FALSE(powerStateMachine->IsScreenOn());
408     powerStateMachine->IncreaseExternalScreenNumber();
409     EXPECT_EQ(powerStateMachine->GetExternalScreenNumber(), 1);
410     g_pmsTest->externalScreenListener_->OnDisconnect(SCREEN_A_ID);
411     EXPECT_FALSE(powerStateMachine->IsScreenOn());
412 
413     // case 3: isSwitchOpen:false, isScreenOn:true, and there's only 1 external screen
414     // Mock open switch to wakeup deivce
415     powerStateMachine->SetSwitchState(true);
416     g_service->WakeupDevice(
417         static_cast<int64_t>(time(nullptr)), WakeupDeviceType::WAKEUP_DEVICE_SWITCH, "PowerMgrServiceNative015");
418     EXPECT_TRUE(powerStateMachine->IsScreenOn());
419     powerStateMachine->IncreaseExternalScreenNumber();
420     EXPECT_EQ(powerStateMachine->GetExternalScreenNumber(), 1);
421     // Mock close switch to suspend device when switch's action is configured as ACTION_NONE
422     powerStateMachine->SetSwitchState(false);
423     auto suspendController = g_service->GetSuspendController();
424     suspendController->ControlListener(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH, SuspendAction::ACTION_NONE, 0);
425     EXPECT_TRUE(powerStateMachine->IsScreenOn());
426     g_pmsTest->externalScreenListener_->OnDisconnect(SCREEN_A_ID);
427     EXPECT_FALSE(powerStateMachine->IsScreenOn());
428 
429     // Unregister screen listener
430     g_pmsTest->UnRegisterExternalScreenListener();
431     EXPECT_TRUE(g_pmsTest->externalScreenListener_ == nullptr);
432 #endif
433     POWER_HILOGD(LABEL_TEST, "PowerMgrServiceNative015 end.");
434 }
435 
436 } // namespace
437