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