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_test.h"
17
18 #include <csignal>
19 #include <iostream>
20 #include <thread>
21
22 #include <if_system_ability_manager.h>
23 #include <ipc_skeleton.h>
24 #include <iservice_registry.h>
25 #include <string_ex.h>
26 #include <system_ability_definition.h>
27
28 #include "accesstoken_kit.h"
29 #include "mock_state_action.h"
30 #include "nativetoken_kit.h"
31 #include "power_common.h"
32 #include "power_mgr_client.h"
33 #include "power_mgr_service.h"
34 #include "power_utils.h"
35 #include "setting_helper.h"
36 #include "token_setproc.h"
37
38 using namespace testing::ext;
39 using namespace OHOS::PowerMgr;
40 using namespace OHOS;
41 using namespace std;
42
SetUpTestCase(void)43 void PowerMgrServiceTest::SetUpTestCase(void)
44 {
45 DelayedSpSingleton<PowerMgrService>::GetInstance()->OnStart();
46 }
47
TearDownTestCase(void)48 void PowerMgrServiceTest::TearDownTestCase(void)
49 {
50 }
51
SetUp(void)52 void PowerMgrServiceTest::SetUp(void)
53 {
54 }
55
TearDown(void)56 void PowerMgrServiceTest::TearDown(void)
57 {
58 }
59
60 namespace {
61 constexpr const int64_t STATE_WAIT_TIME_MS = 300;
62 constexpr const int64_t STATE_OFF_WAIT_TIME_MS = 2000;
63
64 /**
65 * @tc.name: PowerMgrService001
66 * @tc.desc: Test PowerMgrService service ready.
67 * @tc.type: FUNC
68 */
69 HWTEST_F (PowerMgrServiceTest, PowerMgrService001, TestSize.Level0)
70 {
71 POWER_HILOGI(LABEL_TEST, "PowerMgrService001 start");
72 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
73 ASSERT_TRUE(sam != nullptr) << "PowerMgrService01 fail to get GetSystemAbilityManager";
74 sptr<IRemoteObject> remoteObject_ = sam->CheckSystemAbility(POWER_MANAGER_SERVICE_ID);
75 ASSERT_TRUE(remoteObject_ != nullptr) << "GetSystemAbility failed.";
76 POWER_HILOGI(LABEL_TEST, "PowerMgrService001 end");
77 }
78
79 /**
80 * @tc.name: PowerMgrService002
81 * @tc.desc: Test PowerMgrService Start and stop.
82 * @tc.type: FUNC
83 */
84 HWTEST_F (PowerMgrServiceTest, PowerMgrService002, TestSize.Level0)
85 {
86 POWER_HILOGI(LABEL_TEST, "PowerMgrService002 start");
87 if (false) {
88 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
89 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService02 fail to get PowerMgrService";
90 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is ready";
91 pmsTest_->OnStart();
92 ASSERT_TRUE(pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is not ready";
93 pmsTest_->OnStop();
94 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ stop fail";
95 pmsTest_->OnStart();
96 ASSERT_TRUE(pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is not ready";
97 pmsTest_->OnStop();
98 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ stop fail";
99 }
100 POWER_HILOGI(LABEL_TEST, "PowerMgrService002 end");
101 }
102
103 /**
104 * @tc.name: PowerMgrService003
105 * @tc.desc: Test overrideScreenOffTime in screenon
106 * @tc.type: FUNC
107 */
108 HWTEST_F (PowerMgrServiceTest, PowerMgrService003, TestSize.Level0)
109 {
110 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService003 start.");
111 uint32_t PARM_THREE = 3;
112 auto& powerMgrClient = PowerMgrClient::GetInstance();
113 powerMgrClient.WakeupDevice();
114 EXPECT_EQ(powerMgrClient.OverrideScreenOffTime(1000), PowerErrors::ERR_OK);
115 sleep(PARM_THREE);
116 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService003: Prepare Fail, Screen is ON.";
117 EXPECT_EQ(powerMgrClient.RestoreScreenOffTime(), PowerErrors::ERR_OK);
118 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService003 end.");
119 }
120
121 /**
122 * @tc.name: PowerMgrService004
123 * @tc.desc: Test overrideScreenOffTime in screenon
124 * @tc.type: FUNC
125 */
126 HWTEST_F (PowerMgrServiceTest, PowerMgrService004, TestSize.Level0)
127 {
128 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService004 start.");
129 auto& powerMgrClient = PowerMgrClient::GetInstance();
130 powerMgrClient.WakeupDevice();
131 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
132 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService004: Prepare Fail, Screen is ON.";
133
134 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService004 end.");
135 }
136
137 /**
138 * @tc.name: PowerMgrService005
139 * @tc.desc: Test overrideScreenOffTime in screenon
140 * @tc.type: FUNC
141 */
142 HWTEST_F (PowerMgrServiceTest, PowerMgrService005, TestSize.Level0)
143 {
144 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService005 start.");
145 auto& powerMgrClient = PowerMgrClient::GetInstance();
146 powerMgrClient.WakeupDevice();
147 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
148 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService005: Prepare Fail, Screen is OFF.";
149
150 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService005 end.");
151 }
152
153 /**
154 * @tc.name: PowerMgrService006
155 * @tc.desc: Test overrideScreenOffTime in screenoff
156 * @tc.type: FUNC
157 */
158 HWTEST_F (PowerMgrServiceTest, PowerMgrService006, TestSize.Level0)
159 {
160 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService006 start.");
161 uint32_t PARM_FIVE = 5;
162 auto& powerMgrClient = PowerMgrClient::GetInstance();
163 powerMgrClient.SuspendDevice();
164 EXPECT_EQ(powerMgrClient.OverrideScreenOffTime(1000), PowerErrors::ERR_OK);
165 powerMgrClient.WakeupDevice();
166 sleep(PARM_FIVE);
167 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService006: Prepare Fail, Screen is ON.";
168 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService006 end.");
169 }
170
171 /**
172 * @tc.name: PowerMgrService007
173 * @tc.desc: Test overrideScreenOffTime in screenoff
174 * @tc.type: FUNC
175 */
176 HWTEST_F (PowerMgrServiceTest, PowerMgrService007, TestSize.Level0)
177 {
178 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService007 start.");
179 auto& powerMgrClient = PowerMgrClient::GetInstance();
180 powerMgrClient.SuspendDevice();
181 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
182 powerMgrClient.WakeupDevice();
183 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService007: Prepare Fail, Screen is ON.";
184
185 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService007 end.");
186 }
187
188 /**
189 * @tc.name: PowerMgrService008
190 * @tc.desc: Test overrideScreenOffTime in screenoff
191 * @tc.type: FUNC
192 */
193 HWTEST_F (PowerMgrServiceTest, PowerMgrService008, TestSize.Level0)
194 {
195 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService008 start.");
196 auto& powerMgrClient = PowerMgrClient::GetInstance();
197 powerMgrClient.SuspendDevice();
198 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
199 powerMgrClient.WakeupDevice();
200 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService008: Prepare Fail, Screen is OFF.";
201
202 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService008 end.");
203 }
204
205 /**
206 * @tc.name: PowerMgrService009
207 * @tc.desc: Test restoreScreenOffTime in screenon
208 * @tc.type: FUNC
209 */
210 HWTEST_F (PowerMgrServiceTest, PowerMgrService009, TestSize.Level0)
211 {
212 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService009 start.");
213 uint32_t PARM_TWO = 2;
214 auto& powerMgrClient = PowerMgrClient::GetInstance();
215 powerMgrClient.WakeupDevice();
216 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000) == PowerErrors::ERR_OK);
217 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
218 sleep(PARM_TWO);
219 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService009: Prepare Fail, Screen is OFF.";
220
221 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService009 end.");
222 }
223
224 /**
225 * @tc.name: PowerMgrService010
226 * @tc.desc: Test restoreScreenOffTime in screenon
227 * @tc.type: FUNC
228 */
229 HWTEST_F (PowerMgrServiceTest, PowerMgrService010, TestSize.Level0)
230 {
231 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService010 start.");
232 auto& powerMgrClient = PowerMgrClient::GetInstance();
233 powerMgrClient.WakeupDevice();
234 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
235 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
236 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService010: Prepare Fail, Screen is OFF.";
237
238 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService010 end.");
239 }
240
241 /**
242 * @tc.name: PowerMgrService011
243 * @tc.desc: Test restoreScreenOffTime in screenon
244 * @tc.type: FUNC
245 */
246 HWTEST_F (PowerMgrServiceTest, PowerMgrService011, TestSize.Level0)
247 {
248 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService011 start.");
249 auto& powerMgrClient = PowerMgrClient::GetInstance();
250 powerMgrClient.WakeupDevice();
251 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);;
252 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
253 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService011: Prepare Fail, Screen is OFF.";
254
255 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService011 end.");
256 }
257
258 /**
259 * @tc.name: PowerMgrService012
260 * @tc.desc: Test restoreScreenOffTime in screenoff
261 * @tc.type: FUNC
262 */
263 HWTEST_F (PowerMgrServiceTest, PowerMgrService012, TestSize.Level0)
264 {
265 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService012 start.");
266 uint32_t PARM_TWO = 2;
267 auto& powerMgrClient = PowerMgrClient::GetInstance();
268 powerMgrClient.SuspendDevice();
269 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000) == PowerErrors::ERR_OK);
270 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
271 powerMgrClient.WakeupDevice();
272 sleep(PARM_TWO);
273 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService012: Prepare Fail, Screen is OFF.";
274
275 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService012 end.");
276 }
277
278 /**
279 * @tc.name: PowerMgrService013
280 * @tc.desc: Test restoreScreenOffTime in screenoff
281 * @tc.type: FUNC
282 */
283 HWTEST_F (PowerMgrServiceTest, PowerMgrService013, TestSize.Level0)
284 {
285 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService013 start.");
286 auto& powerMgrClient = PowerMgrClient::GetInstance();
287 powerMgrClient.SuspendDevice();
288 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
289 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
290 powerMgrClient.WakeupDevice();
291 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService013: Prepare Fail, Screen is OFF.";
292
293 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService013 end.");
294 }
295
296 /**
297 * @tc.name: PowerMgrService014
298 * @tc.desc: Test restoreScreenOffTime in screenoff
299 * @tc.type: FUNC
300 */
301 HWTEST_F (PowerMgrServiceTest, PowerMgrService014, TestSize.Level0)
302 {
303 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService014 start.");
304 auto& powerMgrClient = PowerMgrClient::GetInstance();
305 powerMgrClient.SuspendDevice();
306 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
307 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
308 powerMgrClient.WakeupDevice();
309 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService014: Prepare Fail, Screen is OFF.";
310
311 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService014 end.");
312 }
313
314 /**
315 * @tc.name: PowerMgrService015
316 * @tc.desc: Test Dump
317 * @tc.type: FUNC
318 * @tc.require: issueI650CX
319 */
320 HWTEST_F(PowerMgrServiceTest, PowerMgrService015, TestSize.Level2)
321 {
322 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService015 start.");
323 auto& powerMgrClient = PowerMgrClient::GetInstance();
324 std::vector<std::string> dumpArgs {};
325 std::string expectedDebugInfo = "Power manager dump options";
326 std::string actualDebugInfo = powerMgrClient.Dump(dumpArgs);
327 auto index = actualDebugInfo.find(expectedDebugInfo);
328 EXPECT_TRUE(index != string::npos);
329 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService015 end.");
330 }
331
332 /**
333 * @tc.name: PowerMgrService016
334 * @tc.desc: Test IsStandby
335 * @tc.type: FUNC
336 * @tc.require: issueI7QHBE
337 */
338 HWTEST_F(PowerMgrServiceTest, PowerMgrService016, TestSize.Level2)
339 {
340 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService016 start.");
341 auto& powerMgrClient = PowerMgrClient::GetInstance();
342 bool standby = false;
343 PowerErrors ret = powerMgrClient.IsStandby(standby);
344 EXPECT_NE(ret, PowerErrors::ERR_CONNECTION_FAIL);
345 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService016 end.");
346 }
347
348 /**
349 * @tc.name: PowerMgrService017
350 * @tc.desc: Test QueryRunningLockLists
351 * @tc.type: FUNC
352 * @tc.require: issueI8FCZA
353 */
354 HWTEST_F(PowerMgrServiceTest, PowerMgrService017, TestSize.Level2)
355 {
356 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService017 start.");
357 auto& powerMgrClient = PowerMgrClient::GetInstance();
358 std::map<std::string, RunningLockInfo> runningLockLists;
359 bool ret = powerMgrClient.QueryRunningLockLists(runningLockLists);
360 EXPECT_EQ(ret, true);
361 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService017 end.");
362 }
363
364 /**
365 * @tc.name: PowerMgrService018
366 * @tc.desc: Test RunningLock Deconstructor unlock
367 * @tc.type: FUNC
368 */
369 HWTEST_F (PowerMgrServiceTest, PowerMgrService018, TestSize.Level0)
370 {
371 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService018 start.");
372 auto& powerMgrClient = PowerMgrClient::GetInstance();
373 auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN);
374 ASSERT_TRUE(runningLock != nullptr);
375 runningLock->Lock();
376 ASSERT_TRUE(runningLock->IsUsed()) << "runningLock->IsUsed() != true";
377 runningLock->UnLock();
378 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService018 end.");
379 }
380
381 /**
382 * @tc.name: PowerMgrService019
383 * @tc.desc: Test Pre-light the screen.
384 * @tc.type: FUNC
385 */
386 HWTEST_F (PowerMgrServiceTest, PowerMgrService019, TestSize.Level0)
387 {
388 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService019 start.");
389 auto& powerMgrClient = PowerMgrClient::GetInstance();
390 powerMgrClient.SuspendDevice();
391 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
392
393 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
394 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
395 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_success");
396 EXPECT_EQ(powerMgrClient.IsScreenOn(), true);
397
398 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService019 end.");
399 }
400
401 /**
402 * @tc.name: PowerMgrService020
403 * @tc.desc: Test if the authentication fails, the screen is on.
404 * @tc.type: FUNC
405 */
406 HWTEST_F (PowerMgrServiceTest, PowerMgrService020, TestSize.Level0)
407 {
408 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService020 start.");
409 auto& powerMgrClient = PowerMgrClient::GetInstance();
410 powerMgrClient.SuspendDevice();
411 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
412
413 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
414 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
415 PowerErrors ret =
416 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_fail_screen_on");
417 EXPECT_EQ(ret, PowerErrors::ERR_OK);
418
419 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService020 end.");
420 }
421
422 /**
423 * @tc.name: PowerMgrService021
424 * @tc.desc: Test if the authentication fails, the screen is off.
425 * @tc.type: FUNC
426 */
427 HWTEST_F (PowerMgrServiceTest, PowerMgrService021, TestSize.Level0)
428 {
429 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService021 start.");
430 auto& powerMgrClient = PowerMgrClient::GetInstance();
431 powerMgrClient.SuspendDevice();
432 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
433
434 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
435 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
436 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_fail_screen_off");
437 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
438
439 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService021 end.");
440 }
441
442 /**
443 * @tc.name: PowerMgrService022
444 * @tc.desc: Test PowerMgrService LockScreenAfterTimingOut.
445 * @tc.type: FUNC
446 */
447 HWTEST_F (PowerMgrServiceTest, PowerMgrService022, TestSize.Level0)
448 {
449 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService022 start.");
450 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
451 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService022 fail to get PowerMgrService";
452 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
453 auto runningLockMgr = pmsTest_->GetRunningLockMgr();
454
455 RunningLockParam runningLockParam;
456 runningLockParam.name = "runninglock_screen_on";
457 runningLockParam.type = RunningLockType::RUNNINGLOCK_SCREEN;
458 sptr<IRemoteObject> remoteObject = new RunningLockTokenStub();
459 EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObject, runningLockParam) != nullptr);
460 runningLockMgr->Lock(remoteObject);
461
462 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
463 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
464 pmsTest_->LockScreenAfterTimingOut(true, false, true, nullptr);
465 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
466 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
467 pmsTest_->LockScreenAfterTimingOut(false, false, true, nullptr);
468 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
469 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK);
470 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY),
471 StateChangeReason::STATE_CHANGE_REASON_HARD_KEY);
472 pmsTest_->LockScreenAfterTimingOut(true, true, true, nullptr);
473 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
474 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK);
475 runningLockMgr->UnLock(remoteObject);
476 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
477 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
478 // wait runninglock async task to end, otherwise it will interfere with the next test case
479 pmsTest_->OnStop();
480 ffrt::wait();
481 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService022 end.");
482 }
483
484 /**
485 * @tc.name: PowerMgrService023
486 * @tc.desc: Test transition to DIM state for Timeout.
487 * @tc.type: FUNC
488 */
489 HWTEST_F (PowerMgrServiceTest, PowerMgrService023, TestSize.Level0)
490 {
491 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService023 start.");
492 constexpr const int64_t screenOffTime = 4000;
493 constexpr const int64_t US_PER_MS = 1000;
494 constexpr const uint32_t DELAY_US = 500 * 1000;
495 auto& powerMgrClient = PowerMgrClient::GetInstance();
496 powerMgrClient.WakeupDevice();
497 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
498 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(screenOffTime) == PowerErrors::ERR_OK);
499 // wait till going to DIM
500 usleep((screenOffTime - screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_WAIT_TIME_MS) * US_PER_MS);
501 EXPECT_EQ(powerMgrClient.GetState(), PowerState::DIM);
502 EXPECT_TRUE(powerMgrClient.RefreshActivity());
503 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
504 // wait till going to DIM
505 usleep((screenOffTime - screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_WAIT_TIME_MS) * US_PER_MS);
506 EXPECT_EQ(powerMgrClient.GetState(), PowerState::DIM);
507 // wait till going to SLEEP
508 usleep((screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_OFF_WAIT_TIME_MS) *
509 US_PER_MS);
510 usleep(DELAY_US);
511 EXPECT_NE(powerMgrClient.GetState(), PowerState::AWAKE);
512 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService023 end.");
513 }
514
515 /**
516 * @tc.name: PowerMgrService024
517 * @tc.desc: Test multithread refreshing.
518 * @tc.type: FUNC
519 */
520 HWTEST_F(PowerMgrServiceTest, PowerMgrService024, TestSize.Level0)
521 {
522 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService024 start.");
523 uint32_t PARM_TEN = 10;
524 constexpr const uint32_t TESTING_DURATION_S = 10;
525 constexpr const uint32_t OPERATION_DELAY_US = 500 * 1000;
526 constexpr const uint32_t EXTREMELY_SHORT_SCREEN_OFF_TIME_MS = 200;
527 constexpr const uint32_t SHORT_SCREEN_OFF_TIME_MS = 800;
528 auto& powerMgrClient = PowerMgrClient::GetInstance();
529 powerMgrClient.OverrideScreenOffTime(SHORT_SCREEN_OFF_TIME_MS);
530 powerMgrClient.WakeupDevice();
531 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
532 std::vector<std::thread> refreshThreads;
533 bool endTask = false;
534 bool endRefresh = false;
__anonddf845d10202() 535 auto refreshTask = [&powerMgrClient, &endRefresh]() {
536 while (!endRefresh) {
537 powerMgrClient.RefreshActivity();
538 }
539 };
540
541 for (int i = 0; i < 100; i++) {
542 refreshThreads.emplace_back(std::thread(refreshTask));
543 }
544
__anonddf845d10302() 545 auto checkingTask = [&powerMgrClient, &endTask]() {
546 while (!endTask) {
547 powerMgrClient.SuspendDevice();
548 usleep(OPERATION_DELAY_US);
549 EXPECT_NE(powerMgrClient.GetState(), PowerState::AWAKE);
550 usleep(OPERATION_DELAY_US);
551 powerMgrClient.WakeupDevice();
552 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
553 usleep(OPERATION_DELAY_US);
554 }
555 };
556 // checks whether refresh tasks may unexpectedly turn screen on
557 std::thread checkingThread(checkingTask);
558 sleep(PARM_TEN);
559 endTask = true;
560 checkingThread.join();
561 // part2 start
562 powerMgrClient.WakeupDevice();
563 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
564 // checks whether timeout events are all blocked
565 powerMgrClient.OverrideScreenOffTime(EXTREMELY_SHORT_SCREEN_OFF_TIME_MS);
566 sleep(PARM_TEN);
567 EXPECT_TRUE(powerMgrClient.IsScreenOn());
568 endRefresh = true;
569 for (auto& thread : refreshThreads) {
570 thread.join();
571 }
572 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService024 end.");
573 }
574
575 /**
576 * @tc.name: PowerMgrService025
577 * @tc.desc: Test StateChangeReason Get
578 * @tc.type: FUNC
579 */
580 HWTEST_F(PowerMgrServiceTest, PowerMgrService025, TestSize.Level2)
581 {
582 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService025 start.");
583 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
584 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService025 failed to get PowerMgrService";
585 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
586 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService025 failed to get PowerStateMachine";
587
588 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_LID),
589 StateChangeReason::STATE_CHANGE_REASON_LID);
590 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH),
591 StateChangeReason::STATE_CHANGE_REASON_SWITCH);
592 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY),
593 StateChangeReason::STATE_CHANGE_REASON_HARD_KEY);
594 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_LID),
595 StateChangeReason::STATE_CHANGE_REASON_LID);
596 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_SWITCH),
597 StateChangeReason::STATE_CHANGE_REASON_SWITCH);
598 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON),
599 StateChangeReason::STATE_CHANGE_REASON_POWER_KEY);
600 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL),
601 StateChangeReason::STATE_CHANGE_REASON_INCOMING_CALL);
602 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_SHELL),
603 StateChangeReason::STATE_CHANGE_REASON_SHELL);
604 pmsTest_->OnStop();
605 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService025 end.");
606 }
607
608 /**
609 * @tc.name: PowerMgrService026
610 * @tc.desc: Test ParseWakeupDeviceType
611 * @tc.type: FUNC
612 */
613 HWTEST_F(PowerMgrServiceTest, PowerMgrService026, TestSize.Level2)
614 {
615 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService026 start.");
616 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
617 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService026 failed to get PowerMgrService";
618 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
619 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService026 failed to get PowerStateMachine";
620
621 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("incoming call"), WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL);
622 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("shell"), WakeupDeviceType::WAKEUP_DEVICE_SHELL);
623 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("pre_bright"), WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT);
624 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("pre_bright_auth_success"),
625 WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS);
626 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("pre_bright_auth_fail_screen_on"),
627 WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON);
628 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("pre_bright_auth_fail_screen_off"),
629 WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF);
630
631 pmsTest_->OnStop();
632 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService026 end.");
633 }
634
635 /**
636 * @tc.name: PowerMgrService027
637 * @tc.desc: Test entering doze state
638 * @tc.type: FUNC
639 */
640 HWTEST_F(PowerMgrServiceTest, PowerMgrService027, TestSize.Level2)
641 {
642 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService027 start.");
643 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
644 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService027 failed to get PowerMgrService";
645 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
646 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService027 failed to get PowerStateMachine";
647 ::testing::NiceMock<MockStateAction>* stateActionMock = new ::testing::NiceMock<MockStateAction>;
648 // will be managed by a unique_ptr in EnableMock
649 stateMaschine_->EnableMock(stateActionMock);
650
651 pmsTest_->SetEnableDoze(false);
652 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_));
653 // prevent powerStateMachine from correcting its state (default action is to return 0 i.e DISPLAY_OFF)
654 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
655 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true);
656 EXPECT_EQ(stateMaschine_->GetState(), PowerState::INACTIVE);
657
658 pmsTest_->SetEnableDoze(true);
659 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_DOZE, ::testing::_));
660 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
661 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true);
662 EXPECT_EQ(stateMaschine_->GetState(), PowerState::INACTIVE);
663 // release mock object
664 auto& stateAction = const_cast<std::shared_ptr<IDeviceStateAction>&>(stateMaschine_->GetStateAction());
665 stateAction.reset();
666 }
667
668 /**
669 * @tc.name: PowerMgrService028
670 * @tc.desc: Test switching doze state
671 * @tc.type: FUNC
672 */
673 HWTEST_F(PowerMgrServiceTest, PowerMgrService028, TestSize.Level2)
674 {
675 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService028 start.");
676 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
677 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService028 failed to get PowerMgrService";
678 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
679 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService028 failed to get PowerStateMachine";
680 ::testing::NiceMock<MockStateAction>* stateActionMock = new ::testing::NiceMock<MockStateAction>;
681 stateMaschine_->EnableMock(stateActionMock);
682
683 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_DOZE, ::testing::_))
684 .Times(0);
685 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
686 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "display_doze");
687
688 EXPECT_CALL(*stateActionMock,
689 SetDisplayState(
690 DisplayState::DISPLAY_DOZE_SUSPEND, StateChangeReason::STATE_CHANGE_REASON_SWITCHING_DOZE_MODE));
691 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_DOZE));
692 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "display_doze_suspend");
693
694 EXPECT_CALL(*stateActionMock,
695 SetDisplayState(DisplayState::DISPLAY_DOZE, StateChangeReason::STATE_CHANGE_REASON_SWITCHING_DOZE_MODE));
696 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_DOZE_SUSPEND));
697 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "display_doze");
698
699 EXPECT_CALL(*stateActionMock,
700 SetDisplayState(DisplayState::DISPLAY_OFF, StateChangeReason::STATE_CHANGE_REASON_SWITCHING_DOZE_MODE));
701 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_DOZE));
702 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "display_off");
703 auto& stateAction = const_cast<std::shared_ptr<IDeviceStateAction>&>(stateMaschine_->GetStateAction());
704 stateAction.reset();
705 }
706
707 /**
708 * @tc.name: PowerMgrService029
709 * @tc.desc: Test observing doze switch
710 * @tc.type: FUNC
711 */
AddPermission()712 void AddPermission()
713 {
714 const char* perms[2];
715 perms[0] = "ohos.permission.MANAGE_SECURE_SETTINGS";
716 perms[1] = "ohos.permission.MANAGE_SETTINGS";
717 NativeTokenInfoParams info = {
718 .dcapsNum = 0,
719 .permsNum = 2,
720 .dcaps = 0,
721 .perms = perms,
722 .acls = NULL,
723 .processName = "powermgr",
724 .aplStr = "system_core",
725 };
726 SetSelfTokenID(GetAccessTokenId(&info));
727 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
728 }
729
730 HWTEST_F(PowerMgrServiceTest, PowerMgrService029, TestSize.Level2)
731 {
732 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService029 start.");
733 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
734 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService029 failed to get PowerMgrService";
735 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
736 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService029 failed to get PowerStateMachine";
737 ::testing::NiceMock<MockStateAction>* stateActionMock = new ::testing::NiceMock<MockStateAction>;
738 stateMaschine_->EnableMock(stateActionMock);
739 AddPermission();
740 SettingHelper::RegisterAodSwitchObserver();
741 std::string originalValue {"0"};
742 SettingProvider::GetInstance(-1).GetStringValue("hw_aod_watch_switch", originalValue);
743 ErrCode ret = SettingProvider::GetInstance(-1).PutStringValue("hw_aod_watch_switch", "0", true);
744 EXPECT_EQ(ret, ERR_OK);
745 sleep(1);
746 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_));
747 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
748 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true);
749 EXPECT_EQ(stateMaschine_->GetState(), PowerState::INACTIVE);
750
751 ret = SettingProvider::GetInstance(-1).PutStringValue("hw_aod_watch_switch", "1", true);
752 EXPECT_EQ(ret, ERR_OK);
753 sleep(1);
754 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_DOZE, ::testing::_));
755 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
756 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true);
757 EXPECT_EQ(stateMaschine_->GetState(), PowerState::INACTIVE);
758 auto& stateAction = const_cast<std::shared_ptr<IDeviceStateAction>&>(stateMaschine_->GetStateAction());
759 stateAction.reset();
760 SettingProvider::GetInstance(-1).PutStringValue("hw_aod_watch_switch", originalValue, true);
761 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService029 end.");
762 }
763 }
764