1 /*
2 * Copyright (c) 2016-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 "powermgr_service_native_test.h"
17
18 #include "power_common.h"
19 #include "power_mgr_service.h"
20 #include "power_state_machine.h"
21 #include "powermgr_service_test_proxy.h"
22 #include "running_lock_token_stub.h"
23 #include <datetime_ex.h>
24 #include <if_system_ability_manager.h>
25 #include <iostream>
26 #include <ipc_skeleton.h>
27 #include <string_ex.h>
28
29 using namespace OHOS;
30 using namespace OHOS::PowerMgr;
31 using namespace std;
32 using namespace testing::ext;
33
34 namespace {
35 static sptr<PowerMgrService> g_powerMgrService = nullptr;
36 static std::shared_ptr<PowerMgrServiceTestProxy> g_powerMgrServiceProxy = nullptr;
37 constexpr int32_t DISPLAY_POWER_MANAGER_ID = 3308;
38 const std::string TEST_DEVICE_ID = "test_device_id";
39 } // namespace
40
SetUpTestCase()41 void PowerMgrServiceNativeTest::SetUpTestCase()
42 {
43 constexpr const uint32_t WAIT_INIT_TIME_S = 5;
44 g_powerMgrService = DelayedSpSingleton<PowerMgrService>::GetInstance();
45 g_powerMgrService->OnStart();
46 g_powerMgrService->OnAddSystemAbility(DISPLAY_POWER_MANAGER_ID, TEST_DEVICE_ID);
47
48 if (g_powerMgrServiceProxy == nullptr) {
49 g_powerMgrServiceProxy = std::make_shared<PowerMgrServiceTestProxy>(g_powerMgrService);
50 }
51 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
52 // wait for "SetState for INIT" to be done
53 sleep(WAIT_INIT_TIME_S);
54 }
55
TearDownTestCase()56 void PowerMgrServiceNativeTest::TearDownTestCase()
57 {
58 g_powerMgrService->OnStop();
59 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
60 }
61
OnPowerModeChanged(PowerMode mode)62 void PowerMgrServiceNativeTest::PowerModeTestCallback::OnPowerModeChanged(PowerMode mode)
63 {
64 POWER_HILOGI(LABEL_TEST, "PowerModeTestCallback::OnPowerModeChanged");
65 }
66
OnPowerStateChanged(PowerState state)67 void PowerMgrServiceNativeTest::PowerStateTestCallback::OnPowerStateChanged(PowerState state)
68 {
69 POWER_HILOGI(LABEL_TEST, "PowerStateTestCallback::OnPowerStateChanged");
70 }
71
OnScreenStateChanged(uint32_t state)72 void PowerMgrServiceNativeTest::ScreenOffPreTestCallback::OnScreenStateChanged(uint32_t state)
73 {
74 POWER_HILOGI(LABEL_TEST, "ScreenOffPreTestCallback::OnScreenStateChanged.");
75 }
76
HandleRunningLockMessage(std::string message)77 void PowerMgrServiceNativeTest::PowerRunningLockTestCallback::HandleRunningLockMessage(std::string message)
78 {
79 POWER_HILOGI(LABEL_TEST, "PowerRunningLockTestCallback::HandleRunningLockMessage.");
80 }
81 namespace {
82 /**
83 * @tc.name: PowerMgrServiceNativeTest001
84 * @tc.desc: test RefreshActivity
85 * @tc.type: FUNC
86 * @tc.require: issueI67Z62
87 */
88 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest001, TestSize.Level2)
89 {
90 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest001::fun is start");
91 int32_t PARM_TWO = 2;
92 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
93 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
94 g_powerMgrServiceProxy->OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
95 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
96 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
97 g_powerMgrServiceProxy->RefreshActivity(GetTickCount());
98 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
99 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
100 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
101 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest001::fun is end");
102 }
103
104 /**
105 * @tc.name: PowerMgrServiceNativeTest002
106 * @tc.desc: test RefreshActivity
107 * @tc.type: FUNC
108 * @tc.require: issueI67Z62
109 */
110 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest002, TestSize.Level2)
111 {
112 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest002::fun is start");
113 int32_t PARM_TWO = 2;
114 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
115 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
116 g_powerMgrServiceProxy->OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
117 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
118 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
119 g_powerMgrServiceProxy->RefreshActivity(GetTickCount(), UserActivityType::USER_ACTIVITY_TYPE_BUTTON);
120 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
121 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
122 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
123 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest002::fun is end");
124 }
125
126 /**
127 * @tc.name: PowerMgrServiceNativeTest003
128 * @tc.desc: test RefreshActivity
129 * @tc.type: FUNC
130 * @tc.require: issueI67Z62
131 */
132 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest003, TestSize.Level2)
133 {
134 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest003::fun is start");
135 int32_t PARM_TWO = 2;
136 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
137 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
138 g_powerMgrServiceProxy->OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
139 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
140 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
141 g_powerMgrServiceProxy->RefreshActivity(GetTickCount(), UserActivityType::USER_ACTIVITY_TYPE_TOUCH);
142 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
143 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
144 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
145 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest003::fun is end");
146 }
147
148 /**
149 * @tc.name: PowerMgrServiceNativeTest004
150 * @tc.desc: test RefreshActivity
151 * @tc.type: FUNC
152 * @tc.require: issueI67Z62
153 */
154 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest004, TestSize.Level2)
155 {
156 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest004::fun is start");
157 int32_t PARM_TWO = 2;
158 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
159 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
160 g_powerMgrServiceProxy->OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
161 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
162 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
163 g_powerMgrServiceProxy->RefreshActivity(GetTickCount(), UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY);
164 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
165 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
166 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
167 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest004::fun is end");
168 }
169
170 /**
171 * @tc.name: PowerMgrServiceNativeTest005
172 * @tc.desc: test RefreshActivity
173 * @tc.type: FUNC
174 * @tc.require: issueI67Z62
175 */
176 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest005, TestSize.Level2)
177 {
178 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest005::fun is start");
179 int32_t PARM_TWO = 2;
180 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
181 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
182 g_powerMgrServiceProxy->OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
183 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
184 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
185 g_powerMgrServiceProxy->RefreshActivity(GetTickCount(), UserActivityType::USER_ACTIVITY_TYPE_ATTENTION);
186 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
187 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
188
189 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
190 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
191 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest005::fun is end");
192 }
193
194 /**
195 * @tc.name: PowerMgrServiceNativeTest006
196 * @tc.desc: test RefreshActivity
197 * @tc.type: FUNC
198 * @tc.require: issueI67Z62
199 */
200 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest006, TestSize.Level2)
201 {
202 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest006::fun is start");
203 int32_t PARM_TWO = 2;
204 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
205 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
206 g_powerMgrServiceProxy->OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
207 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
208 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
209 g_powerMgrServiceProxy->RefreshActivity(GetTickCount(), UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE);
210 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
211 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
212
213 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
214 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
215 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest006::fun is end");
216 }
217
218 /**
219 * @tc.name: PowerMgrServiceNativeTest007
220 * @tc.desc: test RefreshActivity
221 * @tc.type: FUNC
222 * @tc.require: issueI67Z62
223 */
224 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest007, TestSize.Level2)
225 {
226 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest007::fun is start");
227 int32_t PARM_TWO = 2;
228 UserActivityType abnormaltype = UserActivityType(9);
229 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
230 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
231 g_powerMgrServiceProxy->OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS);
232 usleep(SCREEN_OFF_WAIT_TIME_S * TRANSFER_NS_TO_MS / PARM_TWO);
233 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
234 g_powerMgrServiceProxy->RefreshActivity(GetTickCount(), abnormaltype);
235 usleep(SCREEN_OFF_WAIT_TIME_S * TRANSFER_NS_TO_MS / PARM_TWO);
236 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
237 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
238 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest007::fun is end");
239 }
240
241 /**
242 * @tc.name: PowerMgrServiceNativeTest008
243 * @tc.desc: test WakeupDevice
244 * @tc.type: FUNC
245 * @tc.require: issueI67Z62
246 */
247 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest008, TestSize.Level0)
248 {
249 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest008::fun is start");
250 int32_t wakeupReason = (static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + 1;
251 WakeupDeviceType abnormaltype = WakeupDeviceType(wakeupReason);
252
253 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
254 sleep(SLEEP_WAIT_TIME_S);
255 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
256 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), abnormaltype);
257 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
258 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest008::fun is end");
259 }
260
261 /**
262 * @tc.name: PowerMgrServiceNativeTest009
263 * @tc.desc: test Suspend Device
264 * @tc.type: FUNC
265 * @tc.require: issueI67Z62
266 */
267 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest009, TestSize.Level0)
268 {
269 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest009::fun is start");
270 int32_t suspendReason = (static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_MAX)) + 1;
271 SuspendDeviceType abnormaltype = SuspendDeviceType(suspendReason);
272
273 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
274 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
275 g_powerMgrServiceProxy->SuspendDevice(GetTickCount(), abnormaltype, false);
276 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
277
278 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
279 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest009::fun is end");
280 }
281
282 /**
283 * @tc.name: PowerMgrServiceNativeTest010
284 * @tc.desc: test SCREEN_ON RunningLock
285 * @tc.type: FUNC
286 * @tc.require: issueI67Z62
287 */
288 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest010, TestSize.Level2)
289 {
290 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest010:Start");
291 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
292 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
293 int32_t time = SLEEP_WAIT_TIME_MS;
294 sptr<IRemoteObject> token = new RunningLockTokenStub();
295 RunningLockInfo runningLockInfo;
296 runningLockInfo.name = "runninglock";
297 runningLockInfo.type = RunningLockType::RUNNINGLOCK_SCREEN;
298 int32_t timeOutMs = 0;
299 pid_t uid = 0;
300 pid_t pid = 0;
301 auto error = g_powerMgrServiceProxy->CreateRunningLock(token, runningLockInfo);
302 EXPECT_TRUE(error == PowerErrors::ERR_OK);
303 EXPECT_FALSE(g_powerMgrServiceProxy->ProxyRunningLock(true, pid, uid));
304 EXPECT_TRUE(g_powerMgrServiceProxy->ProxyRunningLocks(true, {std::make_pair(pid, uid)}));
305 EXPECT_TRUE(g_powerMgrServiceProxy->ResetRunningLocks());
306 g_powerMgrServiceProxy->OverrideScreenOffTime(time);
307 g_powerMgrServiceProxy->Lock(token);
308 EXPECT_EQ(g_powerMgrServiceProxy->IsUsed(token), true);
309 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
310 usleep(time * TRANSFER_MS_TO_S);
311 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
312 g_powerMgrServiceProxy->UnLock(token);
313 EXPECT_EQ(g_powerMgrServiceProxy->IsUsed(token), false);
314 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
315 EXPECT_TRUE(g_powerMgrServiceProxy->ReleaseRunningLock(token));
316 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest010:End");
317 }
318
319 /**
320 * @tc.name: PowerMgrServiceNativeTest011
321 * @tc.desc: test SCREEN_ON RunningLock
322 * @tc.type: FUNC
323 * @tc.require: issueI67Z62
324 */
325 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest011, TestSize.Level2)
326 {
327 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest011:Start");
328 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
329 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
330 int32_t time = SLEEP_WAIT_TIME_MS;
331 sptr<IRemoteObject> token = new RunningLockTokenStub();
332 RunningLockInfo runningLockInfo;
333 runningLockInfo.name = "runninglock";
334 runningLockInfo.type = RunningLockType::RUNNINGLOCK_SCREEN;
335 int32_t timeOutMs = 0;
336 auto error = g_powerMgrServiceProxy->CreateRunningLock(token, runningLockInfo);
337 EXPECT_TRUE(error == PowerErrors::ERR_OK);
338 g_powerMgrServiceProxy->OverrideScreenOffTime(time);
339
340 g_powerMgrServiceProxy->Lock(token);
341 EXPECT_EQ(g_powerMgrServiceProxy->IsUsed(token), true);
342 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
343 usleep(time * TRANSFER_MS_TO_S * DOUBLE_TIMES);
344 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
345
346 g_powerMgrServiceProxy->UnLock(token);
347 EXPECT_EQ(g_powerMgrServiceProxy->IsUsed(token), false);
348 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
349 EXPECT_TRUE(g_powerMgrServiceProxy->ReleaseRunningLock(token));
350 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest011:End");
351 }
352
353 /**
354 * @tc.name: PowerMgrServiceNativeTest012
355 * @tc.desc: test SCREEN_ON RunningLock
356 * @tc.type: FUNC
357 * @tc.require: issueI67Z62
358 */
359 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest012, TestSize.Level2)
360 {
361 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest012:Start");
362 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
363 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
364 int32_t time = SLEEP_WAIT_TIME_MS;
365 sptr<IRemoteObject> token = new RunningLockTokenStub();
366 RunningLockInfo runningLockInfo;
367 runningLockInfo.name = "runninglock";
368 runningLockInfo.type = RunningLockType::RUNNINGLOCK_SCREEN;
369 int32_t timeOutMs = 0;
370 auto error = g_powerMgrServiceProxy->CreateRunningLock(token, runningLockInfo);
371 EXPECT_TRUE(error == PowerErrors::ERR_OK);
372 g_powerMgrServiceProxy->OverrideScreenOffTime(time);
373
374 g_powerMgrServiceProxy->Lock(token);
375 EXPECT_EQ(g_powerMgrServiceProxy->IsUsed(token), true);
376 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
377 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
378 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
379
380 g_powerMgrServiceProxy->UnLock(token);
381 EXPECT_EQ(g_powerMgrServiceProxy->IsUsed(token), false);
382 g_powerMgrServiceProxy->OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS);
383 EXPECT_TRUE(g_powerMgrServiceProxy->ReleaseRunningLock(token));
384 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest012:End");
385 }
386
387 /**
388 * @tc.name: PowerMgrServiceNativeTest013
389 * @tc.desc: test SetDisplaySuspend
390 * @tc.type: FUNC
391 * @tc.require: issueI67Z62
392 */
393 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest013, TestSize.Level2)
394 {
395 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest013::fun is start");
396 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
397 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
398 g_powerMgrServiceProxy->SetDisplaySuspend(true);
399
400 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
401 g_powerMgrServiceProxy->SetDisplaySuspend(false);
402 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest013::fun is end");
403 }
404
405 /**
406 * @tc.name: PowerMgrServiceNativeTest014
407 * @tc.desc: test Suspend Device in proxy
408 * @tc.type: FUNC
409 * @tc.require: issueI67Z62
410 */
411 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest014, TestSize.Level0)
412 {
413 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest014::fun is start");
414 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
415 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
416
417 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
418 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
419 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest014::fun is end");
420 }
421
422 /**
423 * @tc.name: PowerMgrServiceNativeTest015
424 * @tc.desc: test Suspend Device
425 * @tc.type: FUNC
426 * @tc.require: issueI67Z62
427 */
428 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest015, TestSize.Level0)
429 {
430 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest015::fun is start");
431 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
432 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
433
434 g_powerMgrServiceProxy->SuspendDevice(GetTickCount(), SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false);
435 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
436 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest015::fun is end");
437 }
438
439 /**
440 * @tc.name: PowerMgrServiceNativeTest016
441 * @tc.desc: test Suspend Device
442 * @tc.type: FUNC
443 * @tc.require: issueI67Z62
444 */
445 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest016, TestSize.Level0)
446 {
447 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest016::fun is start");
448 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
449 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
450
451 g_powerMgrServiceProxy->SuspendDevice(GetTickCount(), SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false);
452 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
453 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest016::fun is end");
454 }
455
456 /**
457 * @tc.name: PowerMgrServiceNativeTest017
458 * @tc.desc: test Suspend Device
459 * @tc.type: FUNC
460 * @tc.require: issueI67Z62
461 */
462 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest017, TestSize.Level0)
463 {
464 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest017::fun is start");
465 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
466 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
467
468 g_powerMgrServiceProxy->SuspendDevice(GetTickCount(), SuspendDeviceType::SUSPEND_DEVICE_REASON_LID, false);
469 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
470 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest017::fun is end");
471 }
472
473 /**
474 * @tc.name: PowerMgrServiceNativeTest018
475 * @tc.desc: test Suspend Device
476 * @tc.type: FUNC
477 * @tc.require: issueI67Z62
478 */
479 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest018, TestSize.Level0)
480 {
481 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest018::fun is start");
482 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
483 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
484
485 g_powerMgrServiceProxy->SuspendDevice(GetTickCount(), SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY, false);
486 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
487 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest018::fun is end");
488 }
489
490 /**
491 * @tc.name: PowerMgrServiceNativeTest019
492 * @tc.desc: test Suspend Device
493 * @tc.type: FUNC
494 * @tc.require: issueI67Z62
495 */
496 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest019, TestSize.Level0)
497 {
498 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest019::fun is start");
499 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
500 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
501
502 g_powerMgrServiceProxy->SuspendDevice(GetTickCount(), SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI, false);
503 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
504 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest019::fun is end");
505 }
506
507 /**
508 * @tc.name: PowerMgrServiceNativeTest020
509 * @tc.desc: test Suspend Device
510 * @tc.type: FUNC
511 * @tc.require: issueI67Z62
512 */
513 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest020, TestSize.Level0)
514 {
515 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest020::fun is start");
516 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
517 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
518
519 g_powerMgrServiceProxy->SuspendDevice(GetTickCount(), SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_KEY, false);
520 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
521 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest020::fun is end");
522 }
523
524 /**
525 * @tc.name: PowerMgrServiceNativeTest021
526 * @tc.desc: test Suspend Device
527 * @tc.type: FUNC
528 * @tc.require: issueI67Z62
529 */
530 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest021, TestSize.Level0)
531 {
532 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest021::fun is start");
533 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
534 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
535
536 g_powerMgrServiceProxy->SuspendDevice(
537 GetTickCount(), SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY, false);
538 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
539 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest021::fun is end");
540 }
541
542 /**
543 * @tc.name: PowerMgrServiceNativeTest022
544 * @tc.desc: test Suspend Device
545 * @tc.type: FUNC
546 * @tc.require: issueI67Z62
547 */
548 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest022, TestSize.Level0)
549 {
550 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest022::fun is start");
551 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
552 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
553
554 g_powerMgrServiceProxy->SuspendDevice(
555 GetTickCount(), SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND, false);
556 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
557 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest022::fun is end");
558 }
559
560 /**
561 * @tc.name: PowerMgrServiceNativeTest023
562 * @tc.desc: test WakeupDevice(int64_t timeMs) in proxy
563 * @tc.type: FUNC
564 * @tc.require: issueI67Z62
565 */
566 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest023, TestSize.Level0)
567 {
568 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest023::fun is start");
569 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
570 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
571
572 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
573 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
574 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
575 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest023::fun is end");
576 }
577
578 /**
579 * @tc.name: PowerMgrServiceNativeTest024
580 * @tc.desc: test WakeupDevice
581 * @tc.type: FUNC
582 * @tc.require: issueI67Z62
583 */
584 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest024, TestSize.Level0)
585 {
586 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest024::fun is start");
587 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
588 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
589
590 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN);
591 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
592 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
593 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest024::fun is end");
594 }
595
596 /**
597 * @tc.name: PowerMgrServiceNativeTest025
598 * @tc.desc: test WakeupDevice
599 * @tc.type: FUNC
600 * @tc.require: issueI67Z62
601 */
602 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest025, TestSize.Level0)
603 {
604 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest025::fun is start");
605 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
606 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
607
608 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON);
609 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
610 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
611 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest025::fun is end");
612 }
613
614 /**
615 * @tc.name: PowerMgrServiceNativeTest026
616 * @tc.desc: test WakeupDevice
617 * @tc.type: FUNC
618 * @tc.require: issueI67Z62
619 */
620 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest026, TestSize.Level0)
621 {
622 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest026::fun is start");
623 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
624 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
625
626 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN);
627 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
628 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
629 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest026::fun is end");
630 }
631
632 /**
633 * @tc.name: PowerMgrServiceNativeTest027
634 * @tc.desc: test WakeupDevice
635 * @tc.type: FUNC
636 * @tc.require: issueI67Z62
637 */
638 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest027, TestSize.Level0)
639 {
640 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest027::fun is start");
641 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
642 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
643
644 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_GESTURE);
645 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
646 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
647 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest027::fun is end");
648 }
649
650 /**
651 * @tc.name: PowerMgrServiceNativeTest028
652 * @tc.desc: test WakeupDevice
653 * @tc.type: FUNC
654 * @tc.require: issueI67Z62
655 */
656 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest028, TestSize.Level0)
657 {
658 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest028::fun is start");
659 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
660 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
661
662 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH);
663 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
664 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
665 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest028::fun is end");
666 }
667
668 /**
669 * @tc.name: PowerMgrServiceNativeTest029
670 * @tc.desc: test WakeupDevice
671 * @tc.type: FUNC
672 * @tc.require: issueI67Z62
673 */
674 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest029, TestSize.Level0)
675 {
676 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest029::fun is start");
677 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
678 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
679
680 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY);
681 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
682 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
683 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest029::fun is end");
684 }
685
686 /**
687 * @tc.name: PowerMgrServiceNativeTest030
688 * @tc.desc: test WakeupDevice
689 * @tc.type: FUNC
690 * @tc.require: issueI67Z62
691 */
692 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest030, TestSize.Level0)
693 {
694 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest030::fun is start");
695 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
696 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
697
698 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION);
699 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
700 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
701 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest030::fun is end");
702 }
703
704 /**
705 * @tc.name: PowerMgrServiceNativeTest031
706 * @tc.desc: test WakeupDevice
707 * @tc.type: FUNC
708 * @tc.require: issueI67Z62
709 */
710 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest031, TestSize.Level0)
711 {
712 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest031::fun is start");
713 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
714 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
715
716 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_HDMI);
717 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
718 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
719 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest031::fun is end");
720 }
721
722 /**
723 * @tc.name: PowerMgrServiceNativeTest032
724 * @tc.desc: test WakeupDevice
725 * @tc.type: FUNC
726 * @tc.require: issueI67Z62
727 */
728 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest032, TestSize.Level0)
729 {
730 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest032::fun is start");
731 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
732 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
733
734 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_LID);
735 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
736 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
737 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest032::fun is end");
738 }
739
740 /**
741 * @tc.name: PowerMgrServiceNativeTest033
742 * @tc.desc: test WakeupDevice
743 * @tc.type: FUNC
744 * @tc.require: issueI67Z62
745 */
746 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest033, TestSize.Level0)
747 {
748 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest033::fun is start");
749 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
750 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
751
752 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK);
753 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
754 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
755 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest033::fun is end");
756 }
757
758 /**
759 * @tc.name: PowerMgrServiceNativeTest034
760 * @tc.desc: test WakeupDevice
761 * @tc.type: FUNC
762 * @tc.require: issueI67Z62
763 */
764 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest034, TestSize.Level0)
765 {
766 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest034::fun is start");
767 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
768 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
769
770 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD);
771 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
772 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
773 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest034::fun is end");
774 }
775
776 /**
777 * @tc.name: PowerMgrServiceNativeTest035
778 * @tc.desc: test WakeupDevice
779 * @tc.type: FUNC
780 * @tc.require: issueI67Z62
781 */
782 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest035, TestSize.Level0)
783 {
784 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest035::fun is start");
785 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
786 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
787
788 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_MOUSE);
789 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
790 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
791 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest035::fun is end");
792 }
793
794 /**
795 * @tc.name: PowerMgrServiceNativeTest036
796 * @tc.desc: test IsRunningLockTypeSupported
797 * @tc.type: FUNC
798 * @tc.require: issueI67Z62
799 */
800 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest036, TestSize.Level2)
801 {
802 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest036:Start");
803 auto ret = g_powerMgrServiceProxy->IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BUTT);
804 EXPECT_EQ(ret, false);
805 ret = g_powerMgrServiceProxy->IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_SCREEN);
806 EXPECT_EQ(ret, true);
807 ret = g_powerMgrServiceProxy->IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BACKGROUND);
808 EXPECT_EQ(ret, true);
809 #ifdef HAS_SENSORS_SENSOR_PART
810 ret = g_powerMgrServiceProxy->IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
811 EXPECT_EQ(ret, true);
812 #endif
813 g_powerMgrServiceProxy->WakeupDevice(GetTickCount());
814 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
815 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
816 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
817 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest036:End");
818 }
819
820 /**
821 * @tc.name: PowerMgrServiceNativeTest037
822 * @tc.desc: test Power service function, callback is not nullptr
823 * @tc.type: FUNC
824 * @tc.require: issueI67Z62
825 */
826 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest037, TestSize.Level2)
827 {
828 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest037:Start");
829 sptr<IPowerStateCallback> stateCallback = new PowerStateTestCallback();
830 sptr<IPowerModeCallback> modeCallback = new PowerModeTestCallback();
831 sptr<IScreenOffPreCallback> screenOffPreCallback = new ScreenOffPreTestCallback();
832 sptr<IPowerRunninglockCallback> RunninglockCallback =new PowerRunningLockTestCallback();
833
834 EXPECT_TRUE(g_powerMgrServiceProxy->RegisterPowerStateCallback(stateCallback));
835 EXPECT_TRUE(g_powerMgrServiceProxy->UnRegisterPowerStateCallback(stateCallback));
836 EXPECT_TRUE(g_powerMgrServiceProxy->RegisterPowerModeCallback(modeCallback));
837 EXPECT_TRUE(g_powerMgrServiceProxy->UnRegisterPowerModeCallback(modeCallback));
838 EXPECT_TRUE(g_powerMgrServiceProxy->RegisterScreenStateCallback(4000, screenOffPreCallback));
839 EXPECT_TRUE(g_powerMgrServiceProxy->UnRegisterScreenStateCallback(screenOffPreCallback));
840 EXPECT_TRUE(g_powerMgrServiceProxy->RegisterRunningLockCallback(RunninglockCallback));
841 EXPECT_TRUE(g_powerMgrServiceProxy->UnRegisterRunningLockCallback(RunninglockCallback));
842 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest037:End");
843 }
844
845 /**
846 * @tc.name: PowerMgrServiceNativeTest038
847 * @tc.desc: test Power service dump
848 * @tc.type: FUNC
849 * @tc.require: issueI67Z62
850 */
851 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest038, TestSize.Level0)
852 {
853 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest038:Start");
854 ASSERT_NE(g_powerMgrServiceProxy, nullptr);
855 std::vector<std::string> dumpArgsNone {};
856 std::vector<std::string> dumpArgsHelp {};
857 dumpArgsHelp.push_back("-h");
858
859 std::string expectedDebugInfo;
860 expectedDebugInfo.append("Power manager dump options:\n");
861
862 std::string noneDebugInfo = g_powerMgrServiceProxy->ShellDump(dumpArgsNone, dumpArgsNone.size());
863 auto noneIndex = noneDebugInfo.find(expectedDebugInfo);
864 EXPECT_TRUE(noneIndex != string::npos);
865
866 std::string helpDebugInfo = g_powerMgrServiceProxy->ShellDump(dumpArgsHelp, dumpArgsHelp.size());
867 auto helpIndex = helpDebugInfo.find(expectedDebugInfo);
868 EXPECT_TRUE(helpIndex != string::npos);
869 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest038:End");
870 }
871
872 /**
873 * @tc.name: PowerMgrServiceNativeTest039
874 * @tc.desc: test IsStandby
875 * @tc.type: FUNC
876 * @tc.require: issueI7QHBE
877 */
878 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest039, TestSize.Level2)
879 {
880 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest039::fun is start");
881 bool standby = false;
882 auto error = g_powerMgrServiceProxy->IsStandby(standby);
883 EXPECT_NE(error, PowerErrors::ERR_CONNECTION_FAIL);
884 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest039::fun is end");
885 }
886
887 /**
888 * @tc.name: PowerMgrServiceNativeTest040
889 * @tc.desc: test WakeupDevice
890 * @tc.type: FUNC
891 * @tc.require: #I9G5XH
892 */
893 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest040, TestSize.Level0)
894 {
895 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest040::fun is start");
896 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
897 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
898
899 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_AOD_SLIDING);
900 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
901 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
902 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest040::fun is end");
903 }
904
905 /**
906 * @tc.name: PowerMgrServiceNativeTest041
907 * @tc.desc: test WakeupDevice
908 * @tc.type: FUNC
909 * @tc.require: #I9O7I2
910 */
911 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest041, TestSize.Level0)
912 {
913 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest041::fun is start");
914 g_powerMgrServiceProxy->SuspendDevice(GetTickCount());
915 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), false);
916
917 g_powerMgrServiceProxy->WakeupDevice(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_PEN);
918 EXPECT_EQ(g_powerMgrServiceProxy->GetState(), PowerState::AWAKE);
919 EXPECT_EQ(g_powerMgrServiceProxy->IsScreenOn(), true);
920 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest041::fun is end");
921 }
922 } // namespace
923