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