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