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 "display_manager_lite.h"
30 #include "mock_state_action.h"
31 #include "nativetoken_kit.h"
32 #include "power_common.h"
33 #include "power_mgr_client.h"
34 #define private public
35 #define protected public
36 #include "power_mgr_service.h"
37 #undef private
38 #undef protected
39 #include "power_utils.h"
40 #include "setting_helper.h"
41 #include "token_setproc.h"
42 #include "mock_power_mgr_client.h"
43
44 using namespace testing::ext;
45 using namespace OHOS::PowerMgr;
46 using namespace OHOS;
47 using namespace std;
48
SetUpTestCase(void)49 void PowerMgrServiceTest::SetUpTestCase(void)
50 {
51 DelayedSpSingleton<PowerMgrService>::GetInstance()->OnStart();
52 }
53
TearDownTestCase(void)54 void PowerMgrServiceTest::TearDownTestCase(void)
55 {
56 }
57
SetUp(void)58 void PowerMgrServiceTest::SetUp(void)
59 {
60 }
61
TearDown(void)62 void PowerMgrServiceTest::TearDown(void)
63 {
64 }
65
66 #ifdef POWER_MANAGER_TV_DREAMING
67 class MockDisplayManagerLite : public Rosen::DisplayManagerLite {
68 public:
SuspendBegin(Rosen::PowerStateChangeReason reason)69 bool SuspendBegin(Rosen::PowerStateChangeReason reason)
70 {
71 if (reason == Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_START_DREAM) {
72 return true;
73 }
74 return DisplayManagerLite::SuspendBegin(reason);
75 }
WakeUpBegin(Rosen::PowerStateChangeReason reason)76 bool WakeUpBegin(Rosen::PowerStateChangeReason reason)
77 {
78 if (reason == Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_END_DREAM) {
79 return true;
80 }
81 return DisplayManagerLite::WakeUpBegin(reason);
82 }
83 };
GetInstance()84 Rosen::DisplayManagerLite& Rosen::DisplayManagerLite::GetInstance()
85 {
86 static DisplayManagerLite instance;
87 return static_cast<MockDisplayManagerLite&>(instance);
88 }
89 #endif
90 namespace {
91 constexpr const int64_t STATE_WAIT_TIME_MS = 300;
92 constexpr const int64_t STATE_OFF_WAIT_TIME_MS = 2000;
93 constexpr const int64_t NEXT_WAIT_TIME_S = 1;
94
95 /**
96 * @tc.name: PowerMgrService001
97 * @tc.desc: Test PowerMgrService service ready.
98 * @tc.type: FUNC
99 */
100 HWTEST_F (PowerMgrServiceTest, PowerMgrService001, TestSize.Level0)
101 {
102 POWER_HILOGI(LABEL_TEST, "PowerMgrService001 function start!");
103 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
104 ASSERT_TRUE(sam != nullptr) << "PowerMgrService01 fail to get GetSystemAbilityManager";
105 sptr<IRemoteObject> remoteObject_ = sam->CheckSystemAbility(POWER_MANAGER_SERVICE_ID);
106 ASSERT_TRUE(remoteObject_ != nullptr) << "GetSystemAbility failed.";
107 POWER_HILOGI(LABEL_TEST, "PowerMgrService001 function end!");
108 }
109
110 /**
111 * @tc.name: PowerMgrService002
112 * @tc.desc: Test PowerMgrService Start and stop.
113 * @tc.type: FUNC
114 */
115 HWTEST_F (PowerMgrServiceTest, PowerMgrService002, TestSize.Level0)
116 {
117 POWER_HILOGI(LABEL_TEST, "PowerMgrService002 function start!");
118 if (false) {
119 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
120 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService02 fail to get PowerMgrService";
121 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is ready";
122 pmsTest_->OnStart();
123 ASSERT_TRUE(pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is not ready";
124 pmsTest_->OnStop();
125 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ stop fail";
126 pmsTest_->OnStart();
127 ASSERT_TRUE(pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is not ready";
128 pmsTest_->OnStop();
129 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ stop fail";
130 }
131 POWER_HILOGI(LABEL_TEST, "PowerMgrService002 function end!");
132 }
133
134 /**
135 * @tc.name: PowerMgrService003
136 * @tc.desc: Test overrideScreenOffTime in screenon
137 * @tc.type: FUNC
138 */
139 HWTEST_F (PowerMgrServiceTest, PowerMgrService003, TestSize.Level0)
140 {
141 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService003 function start!");
142 uint32_t PARM_THREE = 3;
143 auto& powerMgrClient = PowerMgrClient::GetInstance();
144 powerMgrClient.WakeupDevice();
145 usleep(50000);
146 EXPECT_EQ(powerMgrClient.OverrideScreenOffTime(1000), PowerErrors::ERR_OK);
147 sleep(PARM_THREE);
148 EXPECT_EQ(powerMgrClient.IsFoldScreenOn(), false) << "PowerMgrService003: Prepare Fail, Screen is ON.";
149 EXPECT_EQ(powerMgrClient.RestoreScreenOffTime(), PowerErrors::ERR_OK);
150 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService003 function end!");
151 }
152
153 /**
154 * @tc.name: PowerMgrService004
155 * @tc.desc: Test overrideScreenOffTime in screenon
156 * @tc.type: FUNC
157 */
158 HWTEST_F (PowerMgrServiceTest, PowerMgrService004, TestSize.Level0)
159 {
160 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService004 function start!");
161 auto& powerMgrClient = PowerMgrClient::GetInstance();
162 powerMgrClient.WakeupDevice();
163 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
164 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService004: Prepare Fail, Screen is ON.";
165
166 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService004 function end!");
167 }
168
169 /**
170 * @tc.name: PowerMgrService005
171 * @tc.desc: Test overrideScreenOffTime in screenon
172 * @tc.type: FUNC
173 */
174 HWTEST_F (PowerMgrServiceTest, PowerMgrService005, TestSize.Level0)
175 {
176 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService005 function start!");
177 auto& powerMgrClient = PowerMgrClient::GetInstance();
178 powerMgrClient.WakeupDevice();
179 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
180 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService005: Prepare Fail, Screen is OFF.";
181
182 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService005 function end!");
183 }
184
185 /**
186 * @tc.name: PowerMgrService006
187 * @tc.desc: Test overrideScreenOffTime in screenoff
188 * @tc.type: FUNC
189 */
190 HWTEST_F (PowerMgrServiceTest, PowerMgrService006, TestSize.Level0)
191 {
192 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService006 function start!");
193 uint32_t PARM_THREE = 3;
194 auto& powerMgrClient = PowerMgrClient::GetInstance();
195 powerMgrClient.SuspendDevice();
196 EXPECT_EQ(powerMgrClient.OverrideScreenOffTime(1000), PowerErrors::ERR_OK);
197 powerMgrClient.WakeupDevice();
198 sleep(PARM_THREE);
199 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService006: Prepare Fail, Screen is ON.";
200 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService006 function end!");
201 }
202
203 /**
204 * @tc.name: PowerMgrService007
205 * @tc.desc: Test overrideScreenOffTime in screenoff
206 * @tc.type: FUNC
207 */
208 HWTEST_F (PowerMgrServiceTest, PowerMgrService007, TestSize.Level0)
209 {
210 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService007 function start!");
211 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
212 powerMgrClient.SuspendDevice();
213 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
214 powerMgrClient.WakeupDevice();
215 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService007: Prepare Fail, Screen is ON.";
216
217 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService007 function end!");
218 }
219
220 /**
221 * @tc.name: PowerMgrService008
222 * @tc.desc: Test overrideScreenOffTime in screenoff
223 * @tc.type: FUNC
224 */
225 HWTEST_F (PowerMgrServiceTest, PowerMgrService008, TestSize.Level0)
226 {
227 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService008 function start!");
228 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
229 powerMgrClient.SuspendDevice();
230 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
231 powerMgrClient.WakeupDevice();
232 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService008: Prepare Fail, Screen is OFF.";
233
234 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService008 function end!");
235 }
236
237 /**
238 * @tc.name: PowerMgrService009
239 * @tc.desc: Test restoreScreenOffTime in screenon
240 * @tc.type: FUNC
241 */
242 HWTEST_F (PowerMgrServiceTest, PowerMgrService009, TestSize.Level0)
243 {
244 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService009 function start!");
245 uint32_t PARM_TWO = 2;
246 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
247 powerMgrClient.WakeupDevice();
248 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000) == PowerErrors::ERR_OK);
249 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
250 sleep(PARM_TWO);
251 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService009: Prepare Fail, Screen is OFF.";
252
253 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService009 function end!");
254 }
255
256 /**
257 * @tc.name: PowerMgrService010
258 * @tc.desc: Test restoreScreenOffTime in screenon
259 * @tc.type: FUNC
260 */
261 HWTEST_F (PowerMgrServiceTest, PowerMgrService010, TestSize.Level0)
262 {
263 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService010 function start!");
264 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
265 powerMgrClient.WakeupDevice();
266 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
267 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
268 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService010: Prepare Fail, Screen is OFF.";
269
270 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService010 function end!");
271 }
272
273 /**
274 * @tc.name: PowerMgrService011
275 * @tc.desc: Test restoreScreenOffTime in screenon
276 * @tc.type: FUNC
277 */
278 HWTEST_F (PowerMgrServiceTest, PowerMgrService011, TestSize.Level0)
279 {
280 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService011 function start!");
281 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
282 powerMgrClient.WakeupDevice();
283 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);;
284 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
285 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService011: Prepare Fail, Screen is OFF.";
286
287 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService011 function end!");
288 }
289
290 /**
291 * @tc.name: PowerMgrService012
292 * @tc.desc: Test restoreScreenOffTime in screenoff
293 * @tc.type: FUNC
294 */
295 HWTEST_F (PowerMgrServiceTest, PowerMgrService012, TestSize.Level0)
296 {
297 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService012 function start!");
298 uint32_t PARM_TWO = 2;
299 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
300 powerMgrClient.SuspendDevice();
301 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000) == PowerErrors::ERR_OK);
302 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
303 powerMgrClient.WakeupDevice();
304 sleep(PARM_TWO);
305 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService012: Prepare Fail, Screen is OFF.";
306
307 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService012 function end!");
308 }
309
310 /**
311 * @tc.name: PowerMgrService013
312 * @tc.desc: Test restoreScreenOffTime in screenoff
313 * @tc.type: FUNC
314 */
315 HWTEST_F (PowerMgrServiceTest, PowerMgrService013, TestSize.Level0)
316 {
317 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService013 function start!");
318 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
319 powerMgrClient.SuspendDevice();
320 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0) == PowerErrors::ERR_OK);
321 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
322 powerMgrClient.WakeupDevice();
323 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService013: Prepare Fail, Screen is OFF.";
324
325 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService013 function end!");
326 }
327
328 /**
329 * @tc.name: PowerMgrService014
330 * @tc.desc: Test restoreScreenOffTime in screenoff
331 * @tc.type: FUNC
332 */
333 HWTEST_F (PowerMgrServiceTest, PowerMgrService014, TestSize.Level0)
334 {
335 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService014 function start!");
336 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
337 powerMgrClient.SuspendDevice();
338 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1) == PowerErrors::ERR_OK);
339 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime() == PowerErrors::ERR_OK);
340 powerMgrClient.WakeupDevice();
341 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService014: Prepare Fail, Screen is OFF.";
342
343 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService014 function end!");
344 }
345
346 /**
347 * @tc.name: PowerMgrService015
348 * @tc.desc: Test Dump
349 * @tc.type: FUNC
350 * @tc.require: issueI650CX
351 */
352 HWTEST_F(PowerMgrServiceTest, PowerMgrService015, TestSize.Level2)
353 {
354 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService015 function start!");
355 auto& powerMgrClient = PowerMgrClient::GetInstance();
356 std::vector<std::string> dumpArgs {};
357 std::string expectedDebugInfo = "Power manager dump options";
358 std::string actualDebugInfo = powerMgrClient.Dump(dumpArgs);
359 auto index = actualDebugInfo.find(expectedDebugInfo);
360 EXPECT_TRUE(index != string::npos);
361 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService015 function end!");
362 }
363
364 /**
365 * @tc.name: PowerMgrService016
366 * @tc.desc: Test IsStandby
367 * @tc.type: FUNC
368 * @tc.require: issueI7QHBE
369 */
370 HWTEST_F(PowerMgrServiceTest, PowerMgrService016, TestSize.Level2)
371 {
372 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService016 function start!");
373 auto& powerMgrClient = PowerMgrClient::GetInstance();
374 bool standby = false;
375 PowerErrors ret = powerMgrClient.IsStandby(standby);
376 EXPECT_NE(ret, PowerErrors::ERR_CONNECTION_FAIL);
377 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService016 function end!");
378 }
379
380 /**
381 * @tc.name: PowerMgrService017
382 * @tc.desc: Test QueryRunningLockLists
383 * @tc.type: FUNC
384 * @tc.require: issueI8FCZA
385 */
386 HWTEST_F(PowerMgrServiceTest, PowerMgrService017, TestSize.Level2)
387 {
388 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService017 function start!");
389 auto& powerMgrClient = PowerMgrClient::GetInstance();
390 std::map<std::string, RunningLockInfo> runningLockLists;
391 bool ret = powerMgrClient.QueryRunningLockLists(runningLockLists);
392 EXPECT_EQ(ret, true);
393 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService017 function end!");
394 }
395
396 /**
397 * @tc.name: PowerMgrService018
398 * @tc.desc: Test RunningLock Deconstructor unlock
399 * @tc.type: FUNC
400 */
401 HWTEST_F (PowerMgrServiceTest, PowerMgrService018, TestSize.Level0)
402 {
403 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService018 function start!");
404 auto& powerMgrClient = PowerMgrClient::GetInstance();
405 auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN);
406 ASSERT_TRUE(runningLock != nullptr);
407 runningLock->Lock();
408 ASSERT_TRUE(runningLock->IsUsed()) << "runningLock->IsUsed() != true";
409 runningLock->UnLock();
410 EXPECT_EQ(powerMgrClient.ResetRunningLocks(), true);
411 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService018 function end!");
412 }
413
414 /**
415 * @tc.name: PowerMgrService019
416 * @tc.desc: Test Pre-light the screen.
417 * @tc.type: FUNC
418 */
419 HWTEST_F (PowerMgrServiceTest, PowerMgrService019, TestSize.Level0)
420 {
421 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService019 function start!");
422 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
423 powerMgrClient.SuspendDevice();
424 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
425
426 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
427 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
428 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_success");
429 EXPECT_EQ(powerMgrClient.IsScreenOn(), true);
430
431 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService019 function end!");
432 }
433
434 /**
435 * @tc.name: PowerMgrService020
436 * @tc.desc: Test if the authentication fails, the screen is on.
437 * @tc.type: FUNC
438 */
439 HWTEST_F (PowerMgrServiceTest, PowerMgrService020, TestSize.Level0)
440 {
441 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService020 function start!");
442 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
443 powerMgrClient.SuspendDevice();
444 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
445
446 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
447 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
448 PowerErrors ret =
449 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_fail_screen_on");
450 EXPECT_EQ(ret, PowerErrors::ERR_OK);
451
452 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService020 function end!");
453 }
454
455 /**
456 * @tc.name: PowerMgrService021
457 * @tc.desc: Test if the authentication fails, the screen is off.
458 * @tc.type: FUNC
459 */
460 HWTEST_F (PowerMgrServiceTest, PowerMgrService021, TestSize.Level0)
461 {
462 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService021 function start!");
463 auto& powerMgrClient = MockPowerMgrClient::GetInstance();
464 powerMgrClient.SuspendDevice();
465 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
466
467 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright");
468 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
469 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "pre_bright_auth_fail_screen_off");
470 EXPECT_EQ(powerMgrClient.IsScreenOn(), false);
471
472 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService021 function end!");
473 }
474
475 /**
476 * @tc.name: PowerMgrService022
477 * @tc.desc: Test PowerMgrService LockScreenAfterTimingOut.
478 * @tc.type: FUNC
479 */
480 HWTEST_F (PowerMgrServiceTest, PowerMgrService022, TestSize.Level0)
481 {
482 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService022 function start!");
483 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
484 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService022 fail to get PowerMgrService";
485 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
486 auto runningLockMgr = pmsTest_->GetRunningLockMgr();
487
488 RunningLockParam runningLockParam;
489 runningLockParam.name = "runninglock_screen_on";
490 runningLockParam.type = RunningLockType::RUNNINGLOCK_SCREEN;
491 sptr<IRemoteObject> remoteObject = new RunningLockTokenStub();
492 EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObject, runningLockParam) != nullptr);
493 runningLockMgr->Lock(remoteObject);
494
495 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
496 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
497 pmsTest_->LockScreenAfterTimingOut(true, false, true, nullptr);
498 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
499 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
500 pmsTest_->LockScreenAfterTimingOut(false, false, true, nullptr);
501 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
502 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK);
503 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY),
504 StateChangeReason::STATE_CHANGE_REASON_HARD_KEY);
505 pmsTest_->LockScreenAfterTimingOut(true, true, true, nullptr);
506 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
507 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK);
508 runningLockMgr->UnLock(remoteObject);
509 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT),
510 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
511 // wait runninglock async task to end, otherwise it will interfere with the next test case
512 pmsTest_->OnStop();
513 ffrt::wait();
514 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService022 function end!");
515 }
516
517 /**
518 * @tc.name: PowerMgrService023
519 * @tc.desc: Test transition to DIM state for Timeout.
520 * @tc.type: FUNC
521 */
522 HWTEST_F (PowerMgrServiceTest, PowerMgrService023, TestSize.Level0)
523 {
524 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService023 function start!");
525 constexpr const int64_t screenOffTime = 4000;
526 constexpr const int64_t US_PER_MS = 1000;
527 constexpr const uint32_t DELAY_US = 500 * 1000;
528 auto& powerMgrClient = PowerMgrClient::GetInstance();
529 powerMgrClient.WakeupDevice();
530 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
531 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(screenOffTime) == PowerErrors::ERR_OK);
532 // wait till going to DIM
533 usleep((screenOffTime - screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_WAIT_TIME_MS) * US_PER_MS);
534 EXPECT_EQ(powerMgrClient.GetState(), PowerState::DIM);
535 EXPECT_TRUE(powerMgrClient.RefreshActivity());
536 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
537 // wait till going to DIM
538 usleep((screenOffTime - screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_WAIT_TIME_MS) * US_PER_MS);
539 EXPECT_EQ(powerMgrClient.GetState(), PowerState::DIM);
540 // wait till going to SLEEP
541 usleep((screenOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR + STATE_OFF_WAIT_TIME_MS) *
542 US_PER_MS);
543 usleep(DELAY_US);
544 EXPECT_NE(powerMgrClient.GetState(), PowerState::AWAKE);
545 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService023 function end!");
546 }
547
548 /**
549 * @tc.name: PowerMgrService024
550 * @tc.desc: Test multithread refreshing.
551 * @tc.type: FUNC
552 */
553 HWTEST_F(PowerMgrServiceTest, PowerMgrService024, TestSize.Level0)
554 {
555 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService024 function start!");
556 uint32_t PARM_TEN = 10;
557 constexpr const uint32_t TESTING_DURATION_S = 10;
558 constexpr const uint32_t OPERATION_DELAY_US = 500 * 1000;
559 constexpr const uint32_t EXTREMELY_SHORT_SCREEN_OFF_TIME_MS = 200;
560 constexpr const uint32_t SHORT_SCREEN_OFF_TIME_MS = 800;
561 auto& powerMgrClient = PowerMgrClient::GetInstance();
562 powerMgrClient.OverrideScreenOffTime(SHORT_SCREEN_OFF_TIME_MS);
563 powerMgrClient.WakeupDevice();
564 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
565 std::vector<std::thread> refreshThreads;
566 bool endTask = false;
567 bool endRefresh = false;
__anon6dd628730202() 568 auto refreshTask = [&powerMgrClient, &endRefresh]() {
569 while (!endRefresh) {
570 powerMgrClient.RefreshActivity();
571 }
572 };
573
574 for (int i = 0; i < 100; i++) {
575 refreshThreads.emplace_back(std::thread(refreshTask));
576 }
577
__anon6dd628730302() 578 auto checkingTask = [&powerMgrClient, &endTask]() {
579 while (!endTask) {
580 powerMgrClient.SuspendDevice();
581 usleep(OPERATION_DELAY_US);
582 EXPECT_NE(powerMgrClient.GetState(), PowerState::AWAKE);
583 usleep(OPERATION_DELAY_US);
584 powerMgrClient.WakeupDevice();
585 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
586 usleep(OPERATION_DELAY_US);
587 }
588 };
589 // checks whether refresh tasks may unexpectedly turn screen on
590 std::thread checkingThread(checkingTask);
591 sleep(PARM_TEN);
592 endTask = true;
593 checkingThread.join();
594 // part2 start
595 powerMgrClient.WakeupDevice();
596 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE);
597 // checks whether timeout events are all blocked
598 powerMgrClient.OverrideScreenOffTime(EXTREMELY_SHORT_SCREEN_OFF_TIME_MS);
599 sleep(PARM_TEN);
600 EXPECT_TRUE(powerMgrClient.IsScreenOn());
601 endRefresh = true;
602 for (auto& thread : refreshThreads) {
603 thread.join();
604 }
605 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService024 function end!");
606 }
607
608 /**
609 * @tc.name: PowerMgrService025
610 * @tc.desc: Test StateChangeReason Get
611 * @tc.type: FUNC
612 */
613 HWTEST_F(PowerMgrServiceTest, PowerMgrService025, TestSize.Level2)
614 {
615 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService025 function start!");
616 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
617 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService025 failed to get PowerMgrService";
618 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
619 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService025 failed to get PowerStateMachine";
620
621 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_LID),
622 StateChangeReason::STATE_CHANGE_REASON_LID);
623 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH),
624 StateChangeReason::STATE_CHANGE_REASON_SWITCH);
625 EXPECT_EQ(stateMaschine_->GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY),
626 StateChangeReason::STATE_CHANGE_REASON_HARD_KEY);
627 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_LID),
628 StateChangeReason::STATE_CHANGE_REASON_LID);
629 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_SWITCH),
630 StateChangeReason::STATE_CHANGE_REASON_SWITCH);
631 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON),
632 StateChangeReason::STATE_CHANGE_REASON_POWER_KEY);
633 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL),
634 StateChangeReason::STATE_CHANGE_REASON_INCOMING_CALL);
635 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_SHELL),
636 StateChangeReason::STATE_CHANGE_REASON_SHELL);
637 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_BLUETOOTH_INCOMING_CALL),
638 StateChangeReason::STATE_CHANGE_REASON_BLUETOOTH_INCOMING_CALL);
639 EXPECT_EQ(stateMaschine_->GetReasonByWakeType(WakeupDeviceType::WAKEUP_DEVICE_PICKUP),
640 StateChangeReason::STATE_CHANGE_REASON_PICKUP);
641 pmsTest_->OnStop();
642 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService025 function end!");
643 }
644
645 /**
646 * @tc.name: PowerMgrService026
647 * @tc.desc: Test ParseWakeupDeviceType
648 * @tc.type: FUNC
649 */
650 HWTEST_F(PowerMgrServiceTest, PowerMgrService026, TestSize.Level2)
651 {
652 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService026 function start!");
653 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
654 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService026 failed to get PowerMgrService";
655 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
656 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService026 failed to get PowerStateMachine";
657
658 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("incoming call"), WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL);
659 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("shell"), WakeupDeviceType::WAKEUP_DEVICE_SHELL);
660 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("pre_bright"), WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT);
661 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("pre_bright_auth_success"),
662 WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS);
663 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("pre_bright_auth_fail_screen_on"),
664 WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON);
665 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("pre_bright_auth_fail_screen_off"),
666 WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF);
667 EXPECT_EQ(PowerUtils::ParseWakeupDeviceType("wake up screen:receive bluetooth call"),
668 WakeupDeviceType::WAKEUP_DEVICE_BLUETOOTH_INCOMING_CALL);
669 pmsTest_->OnStop();
670 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService026 function end!");
671 }
672
673 /**
674 * @tc.name: PowerMgrService027
675 * @tc.desc: Test entering doze state
676 * @tc.type: FUNC
677 */
678 HWTEST_F(PowerMgrServiceTest, PowerMgrService027, TestSize.Level2)
679 {
680 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService027 function start!");
681 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
682 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService027 failed to get PowerMgrService";
683 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
684 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService027 failed to get PowerStateMachine";
685 ::testing::NiceMock<MockStateAction>* stateActionMock = new ::testing::NiceMock<MockStateAction>;
686 // will be managed by a unique_ptr in EnableMock
687 stateMaschine_->EnableMock(stateActionMock);
688
689 pmsTest_->SetEnableDoze(false);
690 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_));
691 // prevent powerStateMachine from correcting its state (default action is to return 0 i.e DISPLAY_OFF)
692 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
693 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true);
694 EXPECT_EQ(stateMaschine_->GetState(), PowerState::INACTIVE);
695
696 pmsTest_->SetEnableDoze(true);
697 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_DOZE, ::testing::_));
698 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
699 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true);
700 EXPECT_EQ(stateMaschine_->GetState(), PowerState::INACTIVE);
701 // release mock object
702 auto& stateAction = const_cast<std::shared_ptr<IDeviceStateAction>&>(stateMaschine_->GetStateAction());
703 stateAction.reset();
704 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService027 function end!");
705 }
706
707 /**
708 * @tc.name: PowerMgrService028
709 * @tc.desc: Test switching doze state
710 * @tc.type: FUNC
711 */
712 HWTEST_F(PowerMgrServiceTest, PowerMgrService028, TestSize.Level2)
713 {
714 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService028 function start!");
715 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
716 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService028 failed to get PowerMgrService";
717 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
718 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService028 failed to get PowerStateMachine";
719 ::testing::NiceMock<MockStateAction>* stateActionMock = new ::testing::NiceMock<MockStateAction>;
720 stateMaschine_->EnableMock(stateActionMock);
721
722 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_DOZE, ::testing::_))
723 .Times(0);
724 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
725 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "display_doze");
726
727 EXPECT_CALL(*stateActionMock,
728 SetDisplayState(
729 DisplayState::DISPLAY_DOZE_SUSPEND, StateChangeReason::STATE_CHANGE_REASON_SWITCHING_DOZE_MODE));
730 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_DOZE));
731 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "display_doze_suspend");
732
733 EXPECT_CALL(*stateActionMock,
734 SetDisplayState(DisplayState::DISPLAY_DOZE, StateChangeReason::STATE_CHANGE_REASON_SWITCHING_DOZE_MODE));
735 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_DOZE_SUSPEND));
736 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "display_doze");
737
738 EXPECT_CALL(*stateActionMock,
739 SetDisplayState(DisplayState::DISPLAY_OFF, StateChangeReason::STATE_CHANGE_REASON_SWITCHING_DOZE_MODE));
740 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_DOZE));
741 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "display_off");
742 auto& stateAction = const_cast<std::shared_ptr<IDeviceStateAction>&>(stateMaschine_->GetStateAction());
743 stateAction.reset();
744 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService028 function end!");
745 }
746
747 /**
748 * @tc.name: PowerMgrService029
749 * @tc.desc: Test observing doze switch
750 * @tc.type: FUNC
751 */
AddPermission()752 void AddPermission()
753 {
754 const char* perms[2];
755 perms[0] = "ohos.permission.MANAGE_SECURE_SETTINGS";
756 perms[1] = "ohos.permission.MANAGE_SETTINGS";
757 NativeTokenInfoParams info = {
758 .dcapsNum = 0,
759 .permsNum = 2,
760 .dcaps = 0,
761 .perms = perms,
762 .acls = NULL,
763 .processName = "powermgr",
764 .aplStr = "system_core",
765 };
766 SetSelfTokenID(GetAccessTokenId(&info));
767 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
768 }
769
770 HWTEST_F(PowerMgrServiceTest, PowerMgrService029, TestSize.Level2)
771 {
772 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService029 function start!");
773 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
774 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService029 failed to get PowerMgrService";
775 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
776 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService029 failed to get PowerStateMachine";
777 ::testing::NiceMock<MockStateAction>* stateActionMock = new ::testing::NiceMock<MockStateAction>;
778 stateMaschine_->EnableMock(stateActionMock);
779 AddPermission();
780 SettingHelper::RegisterAodSwitchObserver();
781 std::string originalValue {"0"};
782 SettingProvider::GetInstance(-1).GetStringValue("hw_aod_watch_switch", originalValue);
783 ErrCode ret = SettingProvider::GetInstance(-1).PutStringValue("hw_aod_watch_switch", "0", true);
784 EXPECT_EQ(ret, ERR_OK);
785 sleep(1);
786 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_OFF, ::testing::_));
787 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
788 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true);
789 EXPECT_EQ(stateMaschine_->GetState(), PowerState::INACTIVE);
790
791 ret = SettingProvider::GetInstance(-1).PutStringValue("hw_aod_watch_switch", "1", true);
792 EXPECT_EQ(ret, ERR_OK);
793 sleep(1);
794 EXPECT_CALL(*stateActionMock, SetDisplayState(DisplayState::DISPLAY_DOZE, ::testing::_));
795 EXPECT_CALL(*stateActionMock, GetDisplayState()).WillOnce(::testing::Return(DisplayState::DISPLAY_ON));
796 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true);
797 EXPECT_EQ(stateMaschine_->GetState(), PowerState::INACTIVE);
798 auto& stateAction = const_cast<std::shared_ptr<IDeviceStateAction>&>(stateMaschine_->GetStateAction());
799 stateAction.reset();
800 SettingProvider::GetInstance(-1).PutStringValue("hw_aod_watch_switch", originalValue, true);
801 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService029 function end!");
802 }
803
804
805 #ifdef POWER_MANAGER_TV_DREAMING
806 /**
807 * @tc.name: PowerMgrService030
808 * @tc.desc: Test dream state
809 * @tc.type: FUNC
810 */
811 HWTEST_F(PowerMgrServiceTest, PowerMgrServiceTest030, TestSize.Level2)
812 {
813 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService030 function start!");
814 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
815 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService030 failed to get PowerMgrService";
816 auto stateMaschine_ = pmsTest_->GetPowerStateMachine();
817 ASSERT_TRUE(stateMaschine_ != nullptr) << "PowerMgrService030 failed to get PowerStateMachine";
818 stateMaschine_->Init();
819 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, true); // reset dream state
820 pmsTest_->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_START_DREAM, true); // set dream from interface
821 EXPECT_TRUE(stateMaschine_->SetDreamingState(StateChangeReason::STATE_CHANGE_REASON_START_DREAM));
822 EXPECT_TRUE(stateMaschine_->SetDreamingState(StateChangeReason::STATE_CHANGE_REASON_END_DREAM));
823 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "start_dream");
824 EXPECT_TRUE(stateMaschine_->SetDreamingState(StateChangeReason::STATE_CHANGE_REASON_START_DREAM));
825 pmsTest_->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "end_dream");
826 EXPECT_TRUE(stateMaschine_->SetDreamingState(StateChangeReason::STATE_CHANGE_REASON_END_DREAM));
827 EXPECT_TRUE(stateMaschine_->SetDreamingState(StateChangeReason::STATE_CHANGE_REASON_START_DREAM));
828 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService030 function end!");
829 }
830 #endif
831
832 /**
833 * @tc.name: PowerMgrServiceTest031
834 * @tc.desc: test IsForceSleeping
835 * @tc.type: FUNC
836 * @tc.require: issueICE3O4
837 */
838 HWTEST_F(PowerMgrServiceTest, PowerMgrServiceTest031, TestSize.Level2)
839 {
840 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest031 function start!");
841 auto& powerMgrClient = PowerMgrClient::GetInstance();
842 int32_t wakeupReason = (static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + 1;
843 WakeupDeviceType abnormaltype = WakeupDeviceType(wakeupReason);
844 powerMgrClient.WakeupDevice();
845 sleep(NEXT_WAIT_TIME_S);
846 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false);
847 powerMgrClient.SuspendDevice();
848 sleep(NEXT_WAIT_TIME_S);
849 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false);
850
851 powerMgrClient.WakeupDevice();
852 sleep(NEXT_WAIT_TIME_S);
853 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false);
854 powerMgrClient.ForceSuspendDevice();
855 sleep(NEXT_WAIT_TIME_S);
856 #ifdef POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST
857 EXPECT_EQ(powerMgrClient.IsForceSleeping(), true);
858 #else
859 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false);
860 #endif
861 powerMgrClient.WakeupDevice(abnormaltype);
862 sleep(NEXT_WAIT_TIME_S);
863 #ifdef POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST
864 EXPECT_EQ(powerMgrClient.IsForceSleeping(), true);
865 #else
866 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false);
867 #endif
868 powerMgrClient.WakeupDevice();
869 sleep(NEXT_WAIT_TIME_S);
870 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false);
871 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest031 function end!");
872 }
873
874 /**
875 * @tc.name: PowerMgrService032
876 * @tc.desc: Test ForceSuspendDevice.
877 * @tc.type: FUNC
878 */
879 HWTEST_F(PowerMgrServiceTest, PowerMgrService032, TestSize.Level0)
880 {
881 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService032 function start!");
882 auto& powerMgrClient = PowerMgrClient::GetInstance();
883 EXPECT_EQ(powerMgrClient.ForceSuspendDevice(""), PowerErrors::ERR_OK);
884 powerMgrClient.WakeupDevice();
885 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService032 function end!");
886 }
887
888 /**
889 * @tc.name: PowerMgrService033
890 * @tc.desc: Test Dump.
891 * @tc.type: FUNC
892 */
893 HWTEST_F(PowerMgrServiceTest, PowerMgrService033, TestSize.Level0)
894 {
895 POWER_HILOGI(LABEL_TEST, "PowerMgrService033 function start!");
896 size_t size = 1000;
897 std::vector<std::string> cmdsList;
898 for (size_t i = 0; i < size; i++) {
899 std::string cmd = "test_cmd" + std::to_string(i);
900 cmdsList.push_back(cmd);
901 }
902 auto& powerMgrClient = PowerMgrClient::GetInstance();
903 std::string result = powerMgrClient.Dump(cmdsList);
904
905 POWER_HILOGI(LABEL_TEST, "result : %{public}s", result.c_str());
906 EXPECT_EQ(true, result == "remote error");
907 POWER_HILOGI(LABEL_TEST, "PowerMgrService032 function end!");
908 }
909
910 /**
911 * @tc.name: PowerMgrService034
912 * @tc.desc: Test Dump.
913 * @tc.type: FUNC
914 */
915 HWTEST_F(PowerMgrServiceTest, PowerMgrService034, TestSize.Level0)
916 {
917 POWER_HILOGI(LABEL_TEST, "PowerMgrService034 function start!");
918 size_t size = 5;
919 std::vector<std::string> cmdsList;
920 for (size_t i = 0; i < size; i++) {
921 std::string cmd = "test_cmd" + std::to_string(i);
922 cmdsList.push_back(cmd);
923 }
924 auto& powerMgrClient = PowerMgrClient::GetInstance();
925 std::string result = powerMgrClient.Dump(cmdsList);
926
927 POWER_HILOGI(LABEL_TEST, "result : %{public}s", result.c_str());
928 EXPECT_EQ(true, result.empty());
929 POWER_HILOGI(LABEL_TEST, "PowerMgrService034 function end!");
930 }
931
932 #ifdef POWER_MANAGER_TAKEOVER_SUSPEND
933 class TestTakeOverSuspendCallback : public ITakeOverSuspendCallback {
934 public:
935 TestTakeOverSuspendCallback() = default;
936 virtual ~TestTakeOverSuspendCallback() = default;
937
OnTakeOverSuspend(SuspendDeviceType type)938 bool OnTakeOverSuspend(SuspendDeviceType type) override
939 {
940 return false;
941 }
AsObject()942 sptr<IRemoteObject> AsObject() override
943 {
944 return nullptr;
945 }
946 };
947
948 /**
949 * @tc.name: PowerMgrService035
950 * @tc.desc: Test PowerStateMachine::EmplaceInactive()
951 * @tc.type: FUNC
952 */
953 HWTEST_F(PowerMgrServiceTest, PowerMgrService035, TestSize.Level0) {
954 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService035 function start!");
955 auto powerMgrService = DelayedSpSingleton<PowerMgrService>::GetInstance();
956 std::shared_ptr<PowerStateMachine> stateMachine = powerMgrService->GetPowerStateMachine();
957 stateMachine->EmplaceInactive();
958 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService035 function end!");
959 }
960
961 /**
962 * @tc.name: PowerMgrService036
963 * @tc.desc: Test StateChangeReason Get
964 * @tc.type: FUNC
965 */
966 HWTEST_F(PowerMgrServiceTest, PowerMgrService036, TestSize.Level0) {
967 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService036 function start!");
968 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
969 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService036 failed to get PowerMgrService";
970 auto stateMachine_ = pmsTest_->GetPowerStateMachine();
971 ASSERT_TRUE(stateMachine_ != nullptr) << "PowerMgrService036 failed to get PowerStateMachine";
972
973 stateMachine_->GetSuspendTypeByReason(StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK);
974 stateMachine_->GetSuspendTypeByReason(StateChangeReason::STATE_CHANGE_REASON_SYSTEM);
975 EXPECT_EQ(stateMachine_->GetSuspendTypeByReason(StateChangeReason::STATE_CHANGE_REASON_TIMEOUT),
976 SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT);
977 EXPECT_EQ(stateMachine_->GetSuspendTypeByReason(StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK),
978 SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT);
979 EXPECT_EQ(stateMachine_->GetSuspendTypeByReason(StateChangeReason::STATE_CHANGE_REASON_HARD_KEY),
980 SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY);
981 EXPECT_EQ(stateMachine_->GetSuspendTypeByReason(StateChangeReason::STATE_CHANGE_REASON_SYSTEM),
982 SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND);
983 EXPECT_EQ(stateMachine_->GetSuspendTypeByReason(StateChangeReason::STATE_CHANGE_REASON_UNKNOWN),
984 SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION);
985 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService036 function end!");
986 }
987
988 /**
989 * @tc.name: PowerMgrService037
990 * @tc.desc: Test RegisterSuspendTakeoverCallback
991 * @tc.type: FUNC
992 */
993 HWTEST_F(PowerMgrServiceTest, PowerMgrService037, TestSize.Level0) {
994 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService037 function start!");
995 sptr<TestTakeOverSuspendCallback> callback = new TestTakeOverSuspendCallback();
996 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
997 TakeOverSuspendPriority priority = TakeOverSuspendPriority::HIGH;
998 pmsTest_->RegisterSuspendTakeoverCallback(callback, priority);
999 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService037 function end!");
1000 }
1001
1002 /**
1003 * @tc.name: PowerMgrService038
1004 * @tc.desc: Test UnRegisterSuspendTakeoverCallback
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(PowerMgrServiceTest, PowerMgrService038, TestSize.Level0) {
1008 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService038 function start!");
1009 sptr<TestTakeOverSuspendCallback> callback = new TestTakeOverSuspendCallback();
1010 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
1011 pmsTest_->UnRegisterSuspendTakeoverCallback(callback);
1012 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService038 function end!");
1013 }
1014 #endif
1015 }
1016