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 constexpr int32_t FAIL_VALUE = -1;
39 constexpr int32_t REASON_VALUE = static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION);
40 const std::string API_VERSION = "-1";
41 const std::string TEST_DEVICE_ID = "test_device_id";
42 } // namespace
43
SetUpTestCase()44 void PowerMgrServiceNativeTest::SetUpTestCase()
45 {
46 constexpr const uint32_t WAIT_INIT_TIME_S = 5;
47 g_powerMgrService = DelayedSpSingleton<PowerMgrService>::GetInstance();
48 g_powerMgrService->OnStart();
49 g_powerMgrService->OnAddSystemAbility(DISPLAY_POWER_MANAGER_ID, TEST_DEVICE_ID);
50 int32_t powerError = 1;
51 bool isScreenOn = false;
52
53 if (g_powerMgrServiceProxy == nullptr) {
54 g_powerMgrServiceProxy = std::make_shared<PowerMgrServiceTestProxy>(g_powerMgrService);
55 }
56 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
57 // wait for "SetState for INIT" to be done
58 sleep(WAIT_INIT_TIME_S);
59 }
60
TearDownTestCase()61 void PowerMgrServiceNativeTest::TearDownTestCase()
62 {
63 g_powerMgrService->OnStop();
64 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
65 }
66
OnPowerModeChanged(PowerMode mode)67 void PowerMgrServiceNativeTest::PowerModeTestCallback::OnPowerModeChanged(PowerMode mode)
68 {
69 POWER_HILOGI(LABEL_TEST, "PowerModeTestCallback::OnPowerModeChanged");
70 }
71
OnPowerStateChanged(PowerState state)72 void PowerMgrServiceNativeTest::PowerStateTestCallback::OnPowerStateChanged(PowerState state)
73 {
74 POWER_HILOGI(LABEL_TEST, "PowerStateTestCallback::OnPowerStateChanged");
75 }
76
OnScreenStateChanged(uint32_t state)77 void PowerMgrServiceNativeTest::ScreenOffPreTestCallback::OnScreenStateChanged(uint32_t state)
78 {
79 POWER_HILOGI(LABEL_TEST, "ScreenOffPreTestCallback::OnScreenStateChanged.");
80 }
81
HandleRunningLockMessage(std::string message)82 void PowerMgrServiceNativeTest::PowerRunningLockTestCallback::HandleRunningLockMessage(std::string message)
83 {
84 POWER_HILOGI(LABEL_TEST, "PowerRunningLockTestCallback::HandleRunningLockMessage.");
85 }
86 namespace {
87 /**
88 * @tc.name: PowerMgrServiceNativeTest001
89 * @tc.desc: test RefreshActivity
90 * @tc.type: FUNC
91 * @tc.require: issueI67Z62
92 */
93 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest001, TestSize.Level2)
94 {
95 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest001 function start!");
96 int32_t PARM_TWO = 2;
97 int32_t powerError = 1;
98 bool isScreenOn = false;
99 g_powerMgrServiceProxy->WakeupDeviceIpc(
100 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
101 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
102 EXPECT_EQ(isScreenOn, true);
103 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(SCREEN_OFF_WAIT_TIME_MS, powerError);
104 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
105 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
106 EXPECT_EQ(isScreenOn, true);
107 g_powerMgrServiceProxy->RefreshActivityIpc(GetTickCount());
108 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
109 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
110 EXPECT_EQ(isScreenOn, true);
111 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
112 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest001 function end!");
113 }
114
115 /**
116 * @tc.name: PowerMgrServiceNativeTest002
117 * @tc.desc: test RefreshActivity
118 * @tc.type: FUNC
119 * @tc.require: issueI67Z62
120 */
121 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest002, TestSize.Level2)
122 {
123 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest002 function start!");
124 int32_t PARM_TWO = 2;
125 int32_t powerError = 1;
126 bool isScreenOn = false;
127 g_powerMgrServiceProxy->WakeupDeviceIpc(
128 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
129 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
130 EXPECT_EQ(isScreenOn, true);
131 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(SCREEN_OFF_WAIT_TIME_MS, powerError);
132 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
133 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
134 EXPECT_EQ(isScreenOn, true);
135 int32_t userButton = static_cast<int32_t>(UserActivityType::USER_ACTIVITY_TYPE_BUTTON);
136 g_powerMgrServiceProxy->RefreshActivityIpc(GetTickCount(), userButton);
137 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
138 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
139 EXPECT_EQ(isScreenOn, true);
140 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
141 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest002 function end!");
142 }
143
144 /**
145 * @tc.name: PowerMgrServiceNativeTest003
146 * @tc.desc: test RefreshActivity
147 * @tc.type: FUNC
148 * @tc.require: issueI67Z62
149 */
150 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest003, TestSize.Level2)
151 {
152 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest003 function start!");
153 int32_t PARM_TWO = 2;
154 int32_t powerError = 1;
155 bool isScreenOn = false;
156 g_powerMgrServiceProxy->WakeupDeviceIpc(
157 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
158 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
159 EXPECT_EQ(isScreenOn, true);
160 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(SCREEN_OFF_WAIT_TIME_MS, powerError);
161 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
162 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
163 EXPECT_EQ(isScreenOn, true);
164 int32_t userTouch = static_cast<int32_t>(UserActivityType::USER_ACTIVITY_TYPE_TOUCH);
165 g_powerMgrServiceProxy->RefreshActivityIpc(GetTickCount(), userTouch);
166 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
167 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
168 EXPECT_EQ(isScreenOn, true);
169 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
170 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest003 function end!");
171 }
172
173 /**
174 * @tc.name: PowerMgrServiceNativeTest004
175 * @tc.desc: test RefreshActivity
176 * @tc.type: FUNC
177 * @tc.require: issueI67Z62
178 */
179 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest004, TestSize.Level2)
180 {
181 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest004 function start!");
182 int32_t PARM_TWO = 2;
183 int32_t powerError = 1;
184 bool isScreenOn = false;
185 g_powerMgrServiceProxy->WakeupDeviceIpc(
186 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
187 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
188 EXPECT_EQ(isScreenOn, true);
189 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(SCREEN_OFF_WAIT_TIME_MS, powerError);
190 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
191 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
192 EXPECT_EQ(isScreenOn, true);
193 int32_t userAcc = static_cast<int32_t>(UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY);
194 g_powerMgrServiceProxy->RefreshActivityIpc(GetTickCount(), userAcc);
195 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
196 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
197 EXPECT_EQ(isScreenOn, true);
198 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
199 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest004 function end!");
200 }
201
202 /**
203 * @tc.name: PowerMgrServiceNativeTest005
204 * @tc.desc: test RefreshActivity
205 * @tc.type: FUNC
206 * @tc.require: issueI67Z62
207 */
208 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest005, TestSize.Level2)
209 {
210 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest005 function start!");
211 int32_t PARM_TWO = 2;
212 int32_t powerError = 1;
213 int32_t powerState = -1;
214 bool isScreenOn = false;
215 g_powerMgrServiceProxy->WakeupDeviceIpc(
216 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
217 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
218 EXPECT_EQ(isScreenOn, true);
219 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(SCREEN_OFF_WAIT_TIME_MS, powerError);
220 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
221 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
222 EXPECT_EQ(isScreenOn, true);
223 int32_t userAttention = static_cast<int32_t>(UserActivityType::USER_ACTIVITY_TYPE_ATTENTION);
224 g_powerMgrServiceProxy->RefreshActivityIpc(GetTickCount(), userAttention);
225 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
226 g_powerMgrServiceProxy->GetStateIpc(powerState);
227 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
228
229 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
230 EXPECT_EQ(isScreenOn, true);
231 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
232 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest005 function end!");
233 }
234
235 /**
236 * @tc.name: PowerMgrServiceNativeTest006
237 * @tc.desc: test RefreshActivity
238 * @tc.type: FUNC
239 * @tc.require: issueI67Z62
240 */
241 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest006, TestSize.Level2)
242 {
243 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest006 function start!");
244 int32_t PARM_TWO = 2;
245 int32_t powerError = 1;
246 int32_t powerState = -1;
247 bool isScreenOn = false;
248 g_powerMgrServiceProxy->WakeupDeviceIpc(
249 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
250 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
251 EXPECT_EQ(isScreenOn, true);
252 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(SCREEN_OFF_WAIT_TIME_MS, powerError);
253 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
254 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
255 EXPECT_EQ(isScreenOn, true);
256 int32_t software = static_cast<int32_t>(UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE);
257 g_powerMgrServiceProxy->RefreshActivityIpc(GetTickCount(), software);
258 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO);
259 g_powerMgrServiceProxy->GetStateIpc(powerState);
260 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
261
262 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
263 EXPECT_EQ(isScreenOn, true);
264 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
265 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest006 function end!");
266 }
267
268 /**
269 * @tc.name: PowerMgrServiceNativeTest007
270 * @tc.desc: test RefreshActivity
271 * @tc.type: FUNC
272 * @tc.require: issueI67Z62
273 */
274 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest007, TestSize.Level2)
275 {
276 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest007 function start!");
277 int32_t PARM_TWO = 2;
278 UserActivityType abnormaltype = UserActivityType(9);
279 int32_t powerError = 1;
280 bool isScreenOn = false;
281 g_powerMgrServiceProxy->WakeupDeviceIpc(
282 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
283 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
284 EXPECT_EQ(isScreenOn, true);
285 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(SCREEN_OFF_WAIT_TIME_MS, powerError);
286 usleep(SCREEN_OFF_WAIT_TIME_S * TRANSFER_NS_TO_MS / PARM_TWO);
287 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
288 EXPECT_EQ(isScreenOn, true);
289 g_powerMgrServiceProxy->RefreshActivityIpc(GetTickCount(), static_cast<int32_t>(abnormaltype));
290 usleep(SCREEN_OFF_WAIT_TIME_S * TRANSFER_NS_TO_MS / PARM_TWO);
291 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
292 EXPECT_EQ(isScreenOn, true);
293 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
294 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest007 function end!");
295 }
296
297 /**
298 * @tc.name: PowerMgrServiceNativeTest008
299 * @tc.desc: test WakeupDevice
300 * @tc.type: FUNC
301 * @tc.require: issueI67Z62
302 */
303 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest008, TestSize.Level0)
304 {
305 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest008 function start!");
306 int32_t wakeupReason = (static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + 1;
307 WakeupDeviceType abnormaltype = WakeupDeviceType(wakeupReason);
308 int32_t powerError = 1;
309 bool isScreenOn = false;
310
311 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
312 sleep(SLEEP_WAIT_TIME_S);
313 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
314 EXPECT_EQ(isScreenOn, false);
315 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(), static_cast<int32_t>(abnormaltype),
316 std::string("app call"), API_VERSION, powerError);
317 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
318 EXPECT_EQ(isScreenOn, false);
319 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest008 function end!");
320 }
321
322 /**
323 * @tc.name: PowerMgrServiceNativeTest009
324 * @tc.desc: test Suspend Device
325 * @tc.type: FUNC
326 * @tc.require: issueI67Z62
327 */
328 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest009, TestSize.Level0)
329 {
330 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest009 function start!");
331 int32_t suspendReason = (static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_MAX)) + 1;
332 int32_t powerError = 1;
333 int32_t powerState = -1;
334 bool isScreenOn = false;
335
336 g_powerMgrServiceProxy->WakeupDeviceIpc(
337 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
338 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
339 EXPECT_EQ(isScreenOn, true);
340 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), suspendReason, false, API_VERSION, powerError);
341 g_powerMgrServiceProxy->GetStateIpc(powerState);
342 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
343
344 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
345 EXPECT_EQ(isScreenOn, true);
346 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest009 function end!");
347 }
348
349 /**
350 * @tc.name: PowerMgrServiceNativeTest010
351 * @tc.desc: test SCREEN_ON RunningLock
352 * @tc.type: FUNC
353 * @tc.require: issueI67Z62
354 */
355 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest010, TestSize.Level2)
356 {
357 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest010 function start!");
358 int32_t powerError = 1;
359 int32_t powerState = -1;
360 std::string name;
361 bool isScreenOn = false;
362 bool isUsed = false;
363 g_powerMgrServiceProxy->WakeupDeviceIpc(
364 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
365 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
366 EXPECT_EQ(isScreenOn, true);
367 int32_t time = SLEEP_WAIT_TIME_MS;
368 sptr<IRemoteObject> token = new RunningLockTokenStub();
369 RunningLockInfo runningLockInfo;
370 runningLockInfo.name = "runninglock";
371 runningLockInfo.type = RunningLockType::RUNNINGLOCK_SCREEN;
372 int32_t timeOutMs = 0;
373 pid_t uid = 0;
374 pid_t pid = 0;
375 g_powerMgrServiceProxy->CreateRunningLockIpc(token, runningLockInfo, powerError);
376 EXPECT_TRUE(powerError == static_cast<int32_t>(PowerErrors::ERR_OK));
377 EXPECT_EQ(g_powerMgrServiceProxy->ProxyRunningLockIpc(true, pid, uid), FAIL_VALUE);
378 std::unique_ptr<VectorPair> vectorPairInfos = std::make_unique<VectorPair>();
379 std::vector<std::pair<pid_t, pid_t>> processInfos;
380 processInfos.emplace_back(pid, uid);
381 vectorPairInfos->SetProcessInfos(processInfos);
382 EXPECT_EQ(g_powerMgrServiceProxy->ProxyRunningLocksIpc(true, *vectorPairInfos), ERR_OK);
383 EXPECT_EQ(g_powerMgrServiceProxy->ResetRunningLocksIpc(), ERR_OK);
384 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(time, powerError);
385 g_powerMgrServiceProxy->LockIpc(token, timeOutMs, powerError);
386 g_powerMgrServiceProxy->IsUsedIpc(token, isUsed);
387 EXPECT_EQ(isUsed, true);
388 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
389 EXPECT_EQ(isScreenOn, true);
390 usleep(time * TRANSFER_MS_TO_S);
391 g_powerMgrServiceProxy->GetStateIpc(powerState);
392 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
393 g_powerMgrServiceProxy->UnLockIpc(token, name, powerError);
394 g_powerMgrServiceProxy->IsUsedIpc(token, isUsed);
395 EXPECT_EQ(isUsed, false);
396 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
397 EXPECT_EQ(g_powerMgrServiceProxy->ReleaseRunningLockIpc(token), ERR_OK);
398 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest010 function end!");
399 }
400
401 /**
402 * @tc.name: PowerMgrServiceNativeTest011
403 * @tc.desc: test SCREEN_ON RunningLock
404 * @tc.type: FUNC
405 * @tc.require: issueI67Z62
406 */
407 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest011, TestSize.Level2)
408 {
409 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest011 function start!");
410 int32_t powerError = 1;
411 int32_t powerState = -1;
412 std::string name;
413 bool isScreenOn = false;
414 bool isUsed = false;
415 g_powerMgrServiceProxy->WakeupDeviceIpc(
416 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
417 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
418 EXPECT_EQ(isScreenOn, true);
419 int32_t time = SLEEP_WAIT_TIME_MS;
420 sptr<IRemoteObject> token = new RunningLockTokenStub();
421 RunningLockInfo runningLockInfo;
422 runningLockInfo.name = "runninglock";
423 runningLockInfo.type = RunningLockType::RUNNINGLOCK_SCREEN;
424 int32_t timeOutMs = 0;
425 g_powerMgrServiceProxy->CreateRunningLockIpc(token, runningLockInfo, powerError);
426 EXPECT_TRUE(powerError == static_cast<int32_t>(PowerErrors::ERR_OK));
427 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(time, powerError);
428
429 g_powerMgrServiceProxy->LockIpc(token, timeOutMs, powerError);
430 g_powerMgrServiceProxy->IsUsedIpc(token, isUsed);
431 EXPECT_EQ(isUsed, true);
432 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
433 EXPECT_EQ(isScreenOn, true);
434 usleep(time * TRANSFER_MS_TO_S * DOUBLE_TIMES);
435 g_powerMgrServiceProxy->GetStateIpc(powerState);
436 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
437
438 g_powerMgrServiceProxy->UnLockIpc(token, name, powerError);
439 g_powerMgrServiceProxy->IsUsedIpc(token, isUsed);
440 EXPECT_EQ(isUsed, false);
441 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
442 EXPECT_EQ(g_powerMgrServiceProxy->ReleaseRunningLockIpc(token), ERR_OK);
443 sleep(2);
444 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest011 function end!");
445 }
446
447 /**
448 * @tc.name: PowerMgrServiceNativeTest012
449 * @tc.desc: test SCREEN_ON RunningLock
450 * @tc.type: FUNC
451 * @tc.require: issueI67Z62
452 */
453 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest012, TestSize.Level2)
454 {
455 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest012 function start!");
456 int32_t powerError = 1;
457 std::string name;
458 bool isScreenOn = false;
459 bool isUsed = false;
460 g_powerMgrServiceProxy->WakeupDeviceIpc(
461 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
462 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
463 EXPECT_EQ(isScreenOn, true);
464 int32_t time = SLEEP_WAIT_TIME_MS;
465 sptr<IRemoteObject> token = new RunningLockTokenStub();
466 RunningLockInfo runningLockInfo;
467 runningLockInfo.name = "runninglock";
468 runningLockInfo.type = RunningLockType::RUNNINGLOCK_SCREEN;
469 int32_t timeOutMs = 0;
470 g_powerMgrServiceProxy->CreateRunningLockIpc(token, runningLockInfo, powerError);
471 EXPECT_TRUE(powerError == static_cast<int32_t>(PowerErrors::ERR_OK));
472 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(time, powerError);
473
474 g_powerMgrServiceProxy->LockIpc(token, timeOutMs, powerError);
475 g_powerMgrServiceProxy->IsUsedIpc(token, isUsed);
476 EXPECT_EQ(isUsed, true);
477 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
478 EXPECT_EQ(isScreenOn, true);
479 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
480 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
481 EXPECT_EQ(isScreenOn, false);
482
483 g_powerMgrServiceProxy->UnLockIpc(token, name, powerError);
484 g_powerMgrServiceProxy->IsUsedIpc(token, isUsed);
485 EXPECT_EQ(isUsed, false);
486 g_powerMgrServiceProxy->OverrideScreenOffTimeIpc(PowerStateMachine::DEFAULT_SLEEP_TIME_MS, powerError);
487 EXPECT_EQ(g_powerMgrServiceProxy->ReleaseRunningLockIpc(token), ERR_OK);
488 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest012 function end!");
489 }
490
491 /**
492 * @tc.name: PowerMgrServiceNativeTest013
493 * @tc.desc: test SetDisplaySuspend
494 * @tc.type: FUNC
495 * @tc.require: issueI67Z62
496 */
497 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest013, TestSize.Level2)
498 {
499 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest013 function start!");
500 int32_t powerError = 1;
501 bool isScreenOn = false;
502 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
503 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
504 EXPECT_EQ(isScreenOn, false);
505 g_powerMgrServiceProxy->SetDisplaySuspendIpc(true);
506
507 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
508 EXPECT_EQ(isScreenOn, false);
509 g_powerMgrServiceProxy->SetDisplaySuspendIpc(false);
510 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest013 function end!");
511 }
512
513 /**
514 * @tc.name: PowerMgrServiceNativeTest014
515 * @tc.desc: test Suspend Device in proxy
516 * @tc.type: FUNC
517 * @tc.require: issueI67Z62
518 */
519 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest014, TestSize.Level0)
520 {
521 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest014 function start!");
522 int32_t powerError = 1;
523 bool isScreenOn = false;
524 g_powerMgrServiceProxy->WakeupDeviceIpc(
525 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
526 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
527 EXPECT_EQ(isScreenOn, true);
528
529 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
530 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
531 EXPECT_EQ(isScreenOn, false);
532 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest014 function end!");
533 }
534
535 /**
536 * @tc.name: PowerMgrServiceNativeTest015
537 * @tc.desc: test Suspend Device
538 * @tc.type: FUNC
539 * @tc.require: issueI67Z62
540 */
541 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest015, TestSize.Level0)
542 {
543 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest015 function start!");
544 int32_t powerError = 1;
545 bool isScreenOn = false;
546 g_powerMgrServiceProxy->WakeupDeviceIpc(
547 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
548 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
549 EXPECT_EQ(isScreenOn, true);
550
551 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(),
552 static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN), false, API_VERSION, powerError);
553 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
554 EXPECT_EQ(isScreenOn, false);
555 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest015 function end!");
556 }
557
558 /**
559 * @tc.name: PowerMgrServiceNativeTest016
560 * @tc.desc: test Suspend Device
561 * @tc.type: FUNC
562 * @tc.require: issueI67Z62
563 */
564 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest016, TestSize.Level0)
565 {
566 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest016 function start!");
567 int32_t powerError = 1;
568 bool isScreenOn = false;
569 g_powerMgrServiceProxy->WakeupDeviceIpc(
570 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
571 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
572 EXPECT_EQ(isScreenOn, true);
573
574 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(),
575 static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT), false, API_VERSION, powerError);
576 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
577 EXPECT_EQ(isScreenOn, false);
578 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest016 function end!");
579 }
580
581 /**
582 * @tc.name: PowerMgrServiceNativeTest017
583 * @tc.desc: test Suspend Device
584 * @tc.type: FUNC
585 * @tc.require: issueI67Z62
586 */
587 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest017, TestSize.Level0)
588 {
589 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest017 function start!");
590 int32_t powerError = 1;
591 bool isScreenOn = false;
592 g_powerMgrServiceProxy->WakeupDeviceIpc(
593 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
594 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
595 EXPECT_EQ(isScreenOn, true);
596
597 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(),
598 static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_LID), false, API_VERSION, powerError);
599 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
600 EXPECT_EQ(isScreenOn, false);
601 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest017 function end!");
602 }
603
604 /**
605 * @tc.name: PowerMgrServiceNativeTest018
606 * @tc.desc: test Suspend Device
607 * @tc.type: FUNC
608 * @tc.require: issueI67Z62
609 */
610 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest018, TestSize.Level0)
611 {
612 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest018 function start!");
613 int32_t powerError = 1;
614 bool isScreenOn = false;
615 g_powerMgrServiceProxy->WakeupDeviceIpc(
616 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
617 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
618 EXPECT_EQ(isScreenOn, true);
619
620 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(),
621 static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY), false, API_VERSION, powerError);
622 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
623 EXPECT_EQ(isScreenOn, false);
624 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest018 function end!");
625 }
626
627 /**
628 * @tc.name: PowerMgrServiceNativeTest019
629 * @tc.desc: test Suspend Device
630 * @tc.type: FUNC
631 * @tc.require: issueI67Z62
632 */
633 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest019, TestSize.Level0)
634 {
635 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest019 function start!");
636 int32_t powerError = 1;
637 bool isScreenOn = false;
638 g_powerMgrServiceProxy->WakeupDeviceIpc(
639 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
640 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
641 EXPECT_EQ(isScreenOn, true);
642
643 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(),
644 static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI), false, API_VERSION, powerError);
645 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
646 EXPECT_EQ(isScreenOn, false);
647 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest019 function end!");
648 }
649
650 /**
651 * @tc.name: PowerMgrServiceNativeTest020
652 * @tc.desc: test Suspend Device
653 * @tc.type: FUNC
654 * @tc.require: issueI67Z62
655 */
656 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest020, TestSize.Level0)
657 {
658 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest020 function start!");
659 int32_t powerError = 1;
660 bool isScreenOn = false;
661 g_powerMgrServiceProxy->WakeupDeviceIpc(
662 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
663 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
664 EXPECT_EQ(isScreenOn, true);
665
666 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(),
667 static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_KEY), false, API_VERSION, powerError);
668 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
669 EXPECT_EQ(isScreenOn, false);
670 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest020 function end!");
671 }
672
673 /**
674 * @tc.name: PowerMgrServiceNativeTest021
675 * @tc.desc: test Suspend Device
676 * @tc.type: FUNC
677 * @tc.require: issueI67Z62
678 */
679 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest021, TestSize.Level0)
680 {
681 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest021 function start!");
682 int32_t powerError = 1;
683 bool isScreenOn = false;
684 g_powerMgrServiceProxy->WakeupDeviceIpc(
685 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
686 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
687 EXPECT_EQ(isScreenOn, true);
688
689 int32_t suspendAcc = static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY);
690 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), suspendAcc, false, API_VERSION, powerError);
691 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
692 EXPECT_EQ(isScreenOn, false);
693 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest021 function end!");
694 }
695
696 /**
697 * @tc.name: PowerMgrServiceNativeTest022
698 * @tc.desc: test Suspend Device
699 * @tc.type: FUNC
700 * @tc.require: issueI67Z62
701 */
702 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest022, TestSize.Level0)
703 {
704 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest022 function start!");
705 int32_t powerError = 1;
706 bool isScreenOn = false;
707 g_powerMgrServiceProxy->WakeupDeviceIpc(
708 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
709 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
710 EXPECT_EQ(isScreenOn, true);
711
712 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(),
713 static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND), false, API_VERSION, powerError);
714 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
715 EXPECT_EQ(isScreenOn, false);
716 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest022 function end!");
717 }
718
719 /**
720 * @tc.name: PowerMgrServiceNativeTest023
721 * @tc.desc: test WakeupDevice(int64_t timeMs) in proxy
722 * @tc.type: FUNC
723 * @tc.require: issueI67Z62
724 */
725 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest023, TestSize.Level0)
726 {
727 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest023 function start!");
728 int32_t powerError = 1;
729 int32_t powerState = -1;
730 bool isScreenOn = false;
731 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
732 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
733 EXPECT_EQ(isScreenOn, false);
734
735 g_powerMgrServiceProxy->WakeupDeviceIpc(
736 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
737 g_powerMgrServiceProxy->GetStateIpc(powerState);
738 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
739 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
740 EXPECT_EQ(isScreenOn, true);
741 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest023 function end!");
742 }
743
744 /**
745 * @tc.name: PowerMgrServiceNativeTest024
746 * @tc.desc: test WakeupDevice
747 * @tc.type: FUNC
748 * @tc.require: issueI67Z62
749 */
750 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest024, TestSize.Level0)
751 {
752 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest024 function start!");
753 int32_t powerError = 1;
754 int32_t powerState = -1;
755 bool isScreenOn = false;
756 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
757 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
758 EXPECT_EQ(isScreenOn, false);
759
760 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
761 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN),
762 std::string("app call"), API_VERSION, powerError);
763 g_powerMgrServiceProxy->GetStateIpc(powerState);
764 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
765 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
766 EXPECT_EQ(isScreenOn, true);
767 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest024 function end!");
768 }
769
770 /**
771 * @tc.name: PowerMgrServiceNativeTest025
772 * @tc.desc: test WakeupDevice
773 * @tc.type: FUNC
774 * @tc.require: issueI67Z62
775 */
776 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest025, TestSize.Level0)
777 {
778 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest025 function start!");
779 int32_t powerError = 1;
780 int32_t powerState = -1;
781 bool isScreenOn = false;
782 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
783 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
784 EXPECT_EQ(isScreenOn, false);
785
786 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
787 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON),
788 std::string("app call"), API_VERSION, powerError);
789 g_powerMgrServiceProxy->GetStateIpc(powerState);
790 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
791 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
792 EXPECT_EQ(isScreenOn, true);
793 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest025 function end!");
794 }
795
796 /**
797 * @tc.name: PowerMgrServiceNativeTest026
798 * @tc.desc: test WakeupDevice
799 * @tc.type: FUNC
800 * @tc.require: issueI67Z62
801 */
802 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest026, TestSize.Level0)
803 {
804 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest026 function start!");
805 int32_t powerError = 1;
806 int32_t powerState = -1;
807 bool isScreenOn = false;
808 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
809 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
810 EXPECT_EQ(isScreenOn, false);
811
812 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
813 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN),
814 std::string("app call"), API_VERSION, powerError);
815 g_powerMgrServiceProxy->GetStateIpc(powerState);
816 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
817 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
818 EXPECT_EQ(isScreenOn, true);
819 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest026 function end!");
820 }
821
822 /**
823 * @tc.name: PowerMgrServiceNativeTest027
824 * @tc.desc: test WakeupDevice
825 * @tc.type: FUNC
826 * @tc.require: issueI67Z62
827 */
828 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest027, TestSize.Level0)
829 {
830 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest027 function start!");
831 int32_t powerError = 1;
832 int32_t powerState = -1;
833 bool isScreenOn = false;
834 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
835 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
836 EXPECT_EQ(isScreenOn, false);
837
838 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
839 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_GESTURE),
840 std::string("app call"), API_VERSION, powerError);
841 g_powerMgrServiceProxy->GetStateIpc(powerState);
842 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
843 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
844 EXPECT_EQ(isScreenOn, true);
845 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest027 function end!");
846 }
847
848 /**
849 * @tc.name: PowerMgrServiceNativeTest028
850 * @tc.desc: test WakeupDevice
851 * @tc.type: FUNC
852 * @tc.require: issueI67Z62
853 */
854 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest028, TestSize.Level0)
855 {
856 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest028 function start!");
857 int32_t powerError = 1;
858 int32_t powerState = -1;
859 bool isScreenOn = false;
860 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
861 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
862 EXPECT_EQ(isScreenOn, false);
863
864 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
865 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH),
866 std::string("app call"), API_VERSION, powerError);
867 g_powerMgrServiceProxy->GetStateIpc(powerState);
868 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
869 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
870 EXPECT_EQ(isScreenOn, true);
871 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest028 function end!");
872 }
873
874 /**
875 * @tc.name: PowerMgrServiceNativeTest029
876 * @tc.desc: test WakeupDevice
877 * @tc.type: FUNC
878 * @tc.require: issueI67Z62
879 */
880 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest029, TestSize.Level0)
881 {
882 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest029 function start!");
883 int32_t powerError = 1;
884 int32_t powerState = -1;
885 bool isScreenOn = false;
886 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
887 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
888 EXPECT_EQ(isScreenOn, false);
889
890 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
891 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY),
892 std::string("app call"), API_VERSION, powerError);
893 g_powerMgrServiceProxy->GetStateIpc(powerState);
894 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
895 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
896 EXPECT_EQ(isScreenOn, true);
897 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest029 function end!");
898 }
899
900 /**
901 * @tc.name: PowerMgrServiceNativeTest030
902 * @tc.desc: test WakeupDevice
903 * @tc.type: FUNC
904 * @tc.require: issueI67Z62
905 */
906 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest030, TestSize.Level0)
907 {
908 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest030 function start!");
909 int32_t powerError = 1;
910 int32_t powerState = -1;
911 bool isScreenOn = false;
912 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
913 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
914 EXPECT_EQ(isScreenOn, false);
915
916 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
917 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION),
918 std::string("app call"), API_VERSION, powerError);
919 g_powerMgrServiceProxy->GetStateIpc(powerState);
920 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
921 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
922 EXPECT_EQ(isScreenOn, true);
923 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest030 function end!");
924 }
925
926 /**
927 * @tc.name: PowerMgrServiceNativeTest031
928 * @tc.desc: test WakeupDevice
929 * @tc.type: FUNC
930 * @tc.require: issueI67Z62
931 */
932 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest031, TestSize.Level0)
933 {
934 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest031 function start!");
935 int32_t powerError = 1;
936 int32_t powerState = -1;
937 bool isScreenOn = false;
938 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
939 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
940 EXPECT_EQ(isScreenOn, false);
941
942 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
943 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_HDMI),
944 std::string("app call"), API_VERSION, powerError);
945 g_powerMgrServiceProxy->GetStateIpc(powerState);
946 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
947 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
948 EXPECT_EQ(isScreenOn, true);
949 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest031 function end!");
950 }
951
952 /**
953 * @tc.name: PowerMgrServiceNativeTest032
954 * @tc.desc: test WakeupDevice
955 * @tc.type: FUNC
956 * @tc.require: issueI67Z62
957 */
958 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest032, TestSize.Level0)
959 {
960 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest032 function start!");
961 int32_t powerError = 1;
962 int32_t powerState = -1;
963 bool isScreenOn = false;
964 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
965 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
966 EXPECT_EQ(isScreenOn, false);
967
968 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(), static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_LID),
969 std::string("app call"), API_VERSION, powerError);
970 g_powerMgrServiceProxy->GetStateIpc(powerState);
971 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
972 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
973 EXPECT_EQ(isScreenOn, true);
974 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest032 function end!");
975 }
976
977 /**
978 * @tc.name: PowerMgrServiceNativeTest033
979 * @tc.desc: test WakeupDevice
980 * @tc.type: FUNC
981 * @tc.require: issueI67Z62
982 */
983 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest033, TestSize.Level0)
984 {
985 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest033 function start!");
986 int32_t powerError = 1;
987 int32_t powerState = -1;
988 bool isScreenOn = false;
989 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
990 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
991 EXPECT_EQ(isScreenOn, false);
992
993 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
994 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK),
995 std::string("app call"), API_VERSION, powerError);
996 g_powerMgrServiceProxy->GetStateIpc(powerState);
997 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
998 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
999 EXPECT_EQ(isScreenOn, true);
1000 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest033 function end!");
1001 }
1002
1003 /**
1004 * @tc.name: PowerMgrServiceNativeTest034
1005 * @tc.desc: test WakeupDevice
1006 * @tc.type: FUNC
1007 * @tc.require: issueI67Z62
1008 */
1009 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest034, TestSize.Level0)
1010 {
1011 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest034 function start!");
1012 int32_t powerError = 1;
1013 int32_t powerState = -1;
1014 bool isScreenOn = false;
1015 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
1016 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1017 EXPECT_EQ(isScreenOn, false);
1018
1019 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
1020 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD),
1021 std::string("app call"), API_VERSION, powerError);
1022 g_powerMgrServiceProxy->GetStateIpc(powerState);
1023 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
1024 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1025 EXPECT_EQ(isScreenOn, true);
1026 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest034 function end!");
1027 }
1028
1029 /**
1030 * @tc.name: PowerMgrServiceNativeTest035
1031 * @tc.desc: test WakeupDevice
1032 * @tc.type: FUNC
1033 * @tc.require: issueI67Z62
1034 */
1035 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest035, TestSize.Level0)
1036 {
1037 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest035 function start!");
1038 int32_t powerError = 1;
1039 int32_t powerState = -1;
1040 bool isScreenOn = false;
1041 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
1042 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1043 EXPECT_EQ(isScreenOn, false);
1044
1045 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
1046 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_MOUSE),
1047 std::string("app call"), API_VERSION, powerError);
1048 g_powerMgrServiceProxy->GetStateIpc(powerState);
1049 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
1050 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1051 EXPECT_EQ(isScreenOn, true);
1052 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest035 function end!");
1053 }
1054
1055 /**
1056 * @tc.name: PowerMgrServiceNativeTest036
1057 * @tc.desc: test IsRunningLockTypeSupported
1058 * @tc.type: FUNC
1059 * @tc.require: issueI67Z62
1060 */
1061 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest036, TestSize.Level2)
1062 {
1063 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest036 function start!");
1064 int32_t powerError = 1;
1065 bool lockTypeSupported = false;
1066 bool isScreenOn = false;
1067 g_powerMgrServiceProxy->IsRunningLockTypeSupportedIpc(
1068 static_cast<int32_t>(RunningLockType::RUNNINGLOCK_BUTT), lockTypeSupported);
1069 EXPECT_EQ(lockTypeSupported, false);
1070 g_powerMgrServiceProxy->IsRunningLockTypeSupportedIpc(
1071 static_cast<int32_t>(RunningLockType::RUNNINGLOCK_SCREEN), lockTypeSupported);
1072 EXPECT_EQ(lockTypeSupported, true);
1073 g_powerMgrServiceProxy->IsRunningLockTypeSupportedIpc(
1074 static_cast<int32_t>(RunningLockType::RUNNINGLOCK_BACKGROUND), lockTypeSupported);
1075 EXPECT_EQ(lockTypeSupported, true);
1076 #ifdef HAS_SENSORS_SENSOR_PART
1077 g_powerMgrServiceProxy->IsRunningLockTypeSupportedIpc(
1078 static_cast<int32_t>(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL), lockTypeSupported);
1079 EXPECT_EQ(lockTypeSupported, true);
1080 #endif
1081 g_powerMgrServiceProxy->WakeupDeviceIpc(
1082 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
1083 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1084 EXPECT_EQ(isScreenOn, true);
1085 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
1086 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1087 EXPECT_EQ(isScreenOn, false);
1088 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest036 function end!");
1089 }
1090
1091 /**
1092 * @tc.name: PowerMgrServiceNativeTest037
1093 * @tc.desc: test Power service function, callback is not nullptr
1094 * @tc.type: FUNC
1095 * @tc.require: issueI67Z62
1096 */
1097 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest037, TestSize.Level2)
1098 {
1099 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest037 function start!");
1100 sptr<IPowerStateCallback> stateCallback = new PowerStateTestCallback();
1101 sptr<IPowerModeCallback> modeCallback = new PowerModeTestCallback();
1102 sptr<IScreenOffPreCallback> screenOffPreCallback = new ScreenOffPreTestCallback();
1103 sptr<IPowerRunninglockCallback> RunninglockCallback =new PowerRunningLockTestCallback();
1104
1105 EXPECT_EQ(g_powerMgrServiceProxy->RegisterPowerStateCallbackIpc(stateCallback), ERR_OK);
1106 EXPECT_EQ(g_powerMgrServiceProxy->UnRegisterPowerStateCallbackIpc(stateCallback), ERR_OK);
1107 EXPECT_EQ(g_powerMgrServiceProxy->RegisterPowerModeCallbackIpc(modeCallback), ERR_OK);
1108 EXPECT_EQ(g_powerMgrServiceProxy->UnRegisterPowerModeCallbackIpc(modeCallback), ERR_OK);
1109 EXPECT_EQ(g_powerMgrServiceProxy->RegisterScreenStateCallbackIpc(4000, screenOffPreCallback), ERR_OK);
1110 EXPECT_EQ(g_powerMgrServiceProxy->UnRegisterScreenStateCallbackIpc(screenOffPreCallback), ERR_OK);
1111 EXPECT_EQ(g_powerMgrServiceProxy->RegisterRunningLockCallbackIpc(RunninglockCallback), ERR_OK);
1112 EXPECT_EQ(g_powerMgrServiceProxy->UnRegisterRunningLockCallbackIpc(RunninglockCallback), ERR_OK);
1113 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest037 function end!");
1114 }
1115
1116 /**
1117 * @tc.name: PowerMgrServiceNativeTest038
1118 * @tc.desc: test Power service dump
1119 * @tc.type: FUNC
1120 * @tc.require: issueI67Z62
1121 */
1122 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest038, TestSize.Level0)
1123 {
1124 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest038 function start!");
1125 ASSERT_NE(g_powerMgrServiceProxy, nullptr);
1126 std::vector<std::string> dumpArgsNone {};
1127 std::vector<std::string> dumpArgsHelp {};
1128 dumpArgsHelp.push_back("-h");
1129
1130 std::string expectedDebugInfo;
1131 expectedDebugInfo.append("Power manager dump options:\n");
1132
1133 std::string noneDebugInfo;
1134 g_powerMgrServiceProxy->ShellDumpIpc(dumpArgsNone, dumpArgsNone.size(), noneDebugInfo);
1135 auto noneIndex = noneDebugInfo.find(expectedDebugInfo);
1136 EXPECT_TRUE(noneIndex != string::npos);
1137
1138 std::string helpDebugInfo;
1139 g_powerMgrServiceProxy->ShellDumpIpc(dumpArgsHelp, dumpArgsHelp.size(), helpDebugInfo);
1140 auto helpIndex = helpDebugInfo.find(expectedDebugInfo);
1141 EXPECT_TRUE(helpIndex != string::npos);
1142 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest038 function end!");
1143 }
1144
1145 /**
1146 * @tc.name: PowerMgrServiceNativeTest039
1147 * @tc.desc: test IsStandby
1148 * @tc.type: FUNC
1149 * @tc.require: issueI7QHBE
1150 */
1151 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest039, TestSize.Level2)
1152 {
1153 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest039 function start!");
1154 bool standby = false;
1155 int32_t powerError = 1;
1156 g_powerMgrServiceProxy->IsStandbyIpc(standby, powerError);
1157 EXPECT_NE(powerError, static_cast<int32_t>(PowerErrors::ERR_CONNECTION_FAIL));
1158 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest039 function end!");
1159 }
1160
1161 /**
1162 * @tc.name: PowerMgrServiceNativeTest040
1163 * @tc.desc: test WakeupDevice
1164 * @tc.type: FUNC
1165 * @tc.require: #I9G5XH
1166 */
1167 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest040, TestSize.Level0)
1168 {
1169 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest040 function start!");
1170 int32_t powerError = 1;
1171 int32_t powerState = -1;
1172 bool isScreenOn = false;
1173 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
1174 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1175 EXPECT_EQ(isScreenOn, false);
1176
1177 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(),
1178 static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_AOD_SLIDING),
1179 std::string("app call"), API_VERSION, powerError);
1180 g_powerMgrServiceProxy->GetStateIpc(powerState);
1181 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
1182 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1183 EXPECT_EQ(isScreenOn, true);
1184 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest040 function end!");
1185 }
1186
1187 /**
1188 * @tc.name: PowerMgrServiceNativeTest041
1189 * @tc.desc: test WakeupDevice
1190 * @tc.type: FUNC
1191 * @tc.require: #I9O7I2
1192 */
1193 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest041, TestSize.Level0)
1194 {
1195 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest041 function start!");
1196 int32_t powerError = 1;
1197 int32_t powerState = -1;
1198 bool isScreenOn = false;
1199 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
1200 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1201 EXPECT_EQ(isScreenOn, false);
1202
1203 g_powerMgrServiceProxy->WakeupDeviceIpc(GetTickCount(), static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_PEN),
1204 std::string("app call"), API_VERSION, powerError);
1205 g_powerMgrServiceProxy->GetStateIpc(powerState);
1206 EXPECT_EQ(powerState, static_cast<int32_t>(PowerState::AWAKE));
1207 g_powerMgrServiceProxy->IsScreenOnIpc(true, isScreenOn);
1208 EXPECT_EQ(isScreenOn, true);
1209 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest041 function end!");
1210 }
1211
1212 /**
1213 * @tc.name: PowerMgrServiceNativeTest042
1214 * @tc.desc: test IsForceSleeping
1215 * @tc.type: FUNC
1216 * @tc.require: issueICE3O4
1217 */
1218 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest042, TestSize.Level2)
1219 {
1220 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest042 function start!");
1221 int32_t powerError = 1;
1222 bool ret = true;
1223 int32_t wakeupReason = (static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + 1;
1224 g_powerMgrServiceProxy->WakeupDeviceIpc(
1225 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
1226 sleep(NEXT_WAIT_TIME_S);
1227 g_powerMgrServiceProxy->IsForceSleepingIpc(ret);
1228 EXPECT_EQ(ret, false);
1229
1230 g_powerMgrServiceProxy->SuspendDeviceIpc(GetTickCount(), REASON_VALUE, false, API_VERSION, powerError);
1231 sleep(NEXT_WAIT_TIME_S);
1232 g_powerMgrServiceProxy->IsForceSleepingIpc(ret);
1233 EXPECT_EQ(ret, false);
1234
1235 g_powerMgrServiceProxy->WakeupDeviceIpc(
1236 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
1237 sleep(NEXT_WAIT_TIME_S);
1238 g_powerMgrServiceProxy->IsForceSleepingIpc(ret);
1239 EXPECT_EQ(ret, false);
1240 g_powerMgrServiceProxy->ForceSuspendDeviceIpc(GetTickCount());
1241 sleep(NEXT_WAIT_TIME_S);
1242 g_powerMgrServiceProxy->IsForceSleepingIpc(ret);
1243 #ifdef POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST
1244 EXPECT_EQ(ret, true);
1245 #else
1246 EXPECT_EQ(ret, false);
1247 #endif
1248 g_powerMgrServiceProxy->WakeupDeviceIpc(
1249 GetTickCount(), wakeupReason, std::string("app call"), API_VERSION, powerError);
1250 sleep(NEXT_WAIT_TIME_S);
1251 g_powerMgrServiceProxy->IsForceSleepingIpc(ret);
1252 #ifdef POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST
1253 EXPECT_EQ(ret, true);
1254 #else
1255 EXPECT_EQ(ret, false);
1256 #endif
1257 g_powerMgrServiceProxy->WakeupDeviceIpc(
1258 GetTickCount(), REASON_VALUE, std::string("app call"), API_VERSION, powerError);
1259 sleep(NEXT_WAIT_TIME_S);
1260 g_powerMgrServiceProxy->IsForceSleepingIpc(ret);
1261 EXPECT_EQ(ret, false);
1262 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest042 function end!");
1263 }
1264
1265 /**
1266 * @tc.name: PowerMgrServiceNativeTest043
1267 * @tc.desc: test ProxyRunningLock function.
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNativeTest043, TestSize.Level2)
1271 {
1272 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest043 function start!");
1273 auto& powerMgrClient = PowerMgrClient::GetInstance();
1274 std::shared_ptr<RunningLock> runningLock = powerMgrClient.CreateRunningLock(
1275 "PowerMgrServiceNativeTest043", RunningLockType::RUNNINGLOCK_BACKGROUND);
1276 ASSERT_NE(runningLock, nullptr);
1277
1278 pid_t curUid = getuid();
1279 pid_t curPid = getpid();
1280 runningLock->Lock();
1281 EXPECT_EQ(g_powerMgrServiceProxy->ProxyRunningLockIpc(true, curPid, curUid), ERR_OK);
1282 runningLock->UnLock();
1283 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNativeTest043 function end!");
1284 }
1285 } // namespace
1286