1 /* 2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "power_mgr_client_test.h" 17 18 #include <iostream> 19 20 #include <datetime_ex.h> 21 #include <gtest/gtest.h> 22 #include <if_system_ability_manager.h> 23 #include <ipc_skeleton.h> 24 #include <string_ex.h> 25 #ifdef HAS_DISPLAY_MANAGER_PART 26 #include "display_power_mgr_client.h" 27 #endif 28 #include "power_common.h" 29 #include "power_mgr_client.h" 30 #include "power_mgr_service.h" 31 #include "power_state_machine.h" 32 #include "running_lock_token_stub.h" 33 34 using namespace testing::ext; 35 using namespace OHOS::PowerMgr; 36 using namespace OHOS; 37 using namespace std; 38 39 namespace { 40 constexpr int SLEEP_AFTER_LOCK_TIME_US = 1000 * 1000; 41 42 /** 43 * @tc.name: PowerMgrClient001 44 * @tc.desc: test RefreshActivity 45 * @tc.type: FUNC 46 * @tc.require: issueI5MJZJ 47 */ 48 HWTEST_F(PowerMgrClientTest, PowerMgrClient001, TestSize.Level2) 49 { 50 POWER_HILOGI(LABEL_TEST, "PowerMgrClient001::fun is start!"); 51 uint32_t PARM_TWO = 2; 52 auto& powerMgrClient = PowerMgrClient::GetInstance(); 53 54 powerMgrClient.SuspendDevice(); 55 // Wakeup Device before test 56 powerMgrClient.WakeupDevice(); 57 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient001: Prepare Fail, Screen is OFF."; 58 powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS); 59 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 60 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient001: Prepare Fail, Screen is OFF."; 61 powerMgrClient.RefreshActivity(); 62 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 63 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 64 65 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient001: RefreshActivity Device Fail, Screen is OFF"; 66 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 67 POWER_HILOGI(LABEL_TEST, "PowerMgrClient001::fun is end!"); 68 } 69 70 /** 71 * @tc.name: PowerMgrClient002 72 * @tc.desc: test RefreshActivity 73 * @tc.type: FUNC 74 * @tc.require: issueI5MJZJ 75 */ 76 HWTEST_F(PowerMgrClientTest, PowerMgrClient002, TestSize.Level2) 77 { 78 POWER_HILOGI(LABEL_TEST, "PowerMgrClient002::fun is start!"); 79 uint32_t PARM_TWO = 2; 80 auto& powerMgrClient = PowerMgrClient::GetInstance(); 81 82 powerMgrClient.SuspendDevice(); 83 // Wakeup Device before test 84 powerMgrClient.WakeupDevice(); 85 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient002: Prepare Fail, Screen is OFF."; 86 powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS); 87 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 88 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient002: Prepare Fail, Screen is OFF."; 89 powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_BUTTON); 90 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 91 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 92 93 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient002: RefreshActivity Device Fail, Screen is OFF"; 94 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 95 POWER_HILOGI(LABEL_TEST, "PowerMgrClient002::fun is end!"); 96 } 97 98 /** 99 * @tc.name: PowerMgrClient003 100 * @tc.desc: test RefreshActivity 101 * @tc.type: FUNC 102 * @tc.require: issueI5MJZJ 103 */ 104 HWTEST_F(PowerMgrClientTest, PowerMgrClient003, TestSize.Level2) 105 { 106 POWER_HILOGI(LABEL_TEST, "PowerMgrClient003::fun is start!"); 107 uint32_t PARM_TWO = 2; 108 auto& powerMgrClient = PowerMgrClient::GetInstance(); 109 110 powerMgrClient.SuspendDevice(); 111 // Wakeup Device before test 112 powerMgrClient.WakeupDevice(); 113 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient003: Prepare Fail, Screen is OFF."; 114 powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS); 115 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 116 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient003: Prepare Fail, Screen is OFF."; 117 powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_TOUCH); 118 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 119 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 120 121 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient003: RefreshActivity Device Fail, Screen is OFF"; 122 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 123 POWER_HILOGI(LABEL_TEST, "PowerMgrClient003::fun is end!"); 124 } 125 126 /** 127 * @tc.name: PowerMgrClient004 128 * @tc.desc: test RefreshActivity 129 * @tc.type: FUNC 130 * @tc.require: issueI5MJZJ 131 */ 132 HWTEST_F(PowerMgrClientTest, PowerMgrClient004, TestSize.Level2) 133 { 134 POWER_HILOGI(LABEL_TEST, "PowerMgrClient004::fun is start!"); 135 uint32_t PARM_TWO = 2; 136 auto& powerMgrClient = PowerMgrClient::GetInstance(); 137 138 powerMgrClient.SuspendDevice(); 139 // Wakeup Device before test 140 powerMgrClient.WakeupDevice(); 141 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient004: Prepare Fail, Screen is OFF."; 142 powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS); 143 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 144 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient004: Prepare Fail, Screen is OFF."; 145 powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY); 146 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 147 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 148 149 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient004: RefreshActivity Device Fail, Screen is OFF"; 150 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 151 POWER_HILOGI(LABEL_TEST, "PowerMgrClient004::fun is end!"); 152 } 153 154 /** 155 * @tc.name: PowerMgrClient005 156 * @tc.desc: test RefreshActivity 157 * @tc.type: FUNC 158 * @tc.require: issueI5MJZJ 159 */ 160 HWTEST_F(PowerMgrClientTest, PowerMgrClient005, TestSize.Level2) 161 { 162 POWER_HILOGI(LABEL_TEST, "PowerMgrClient005::fun is start!"); 163 uint32_t PARM_TWO = 2; 164 auto& powerMgrClient = PowerMgrClient::GetInstance(); 165 166 powerMgrClient.SuspendDevice(); 167 // Wakeup Device before test 168 powerMgrClient.WakeupDevice(); 169 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient005: Prepare Fail, Screen is OFF."; 170 powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS); 171 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 172 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient005: Prepare Fail, Screen is OFF."; 173 powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_ATTENTION); 174 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 175 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 176 177 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient005: RefreshActivity Device Fail, Screen is OFF"; 178 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 179 POWER_HILOGI(LABEL_TEST, "PowerMgrClient005::fun is end!"); 180 } 181 182 /** 183 * @tc.name: PowerMgrClient006 184 * @tc.desc: test RefreshActivity 185 * @tc.type: FUNC 186 * @tc.require: issueI5MJZJ 187 */ 188 HWTEST_F(PowerMgrClientTest, PowerMgrClient006, TestSize.Level2) 189 { 190 POWER_HILOGI(LABEL_TEST, "PowerMgrClient006::fun is start!"); 191 uint32_t PARM_TWO = 2; 192 auto& powerMgrClient = PowerMgrClient::GetInstance(); 193 194 powerMgrClient.SuspendDevice(); 195 // Wakeup Device before test 196 powerMgrClient.WakeupDevice(); 197 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient006: Prepare Fail, Screen is OFF."; 198 powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS); 199 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 200 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient006: Prepare Fail, Screen is OFF."; 201 powerMgrClient.RefreshActivity(UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE); 202 sleep(SCREEN_OFF_WAIT_TIME_S / PARM_TWO); 203 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 204 205 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient006: RefreshActivity Device Fail, Screen is OFF"; 206 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 207 POWER_HILOGI(LABEL_TEST, "PowerMgrClient006::fun is end!"); 208 } 209 210 /** 211 * @tc.name: PowerMgrClient007 212 * @tc.desc: test RefreshActivity 213 * @tc.type: FUNC 214 * @tc.require: issueI5MJZJ 215 */ 216 HWTEST_F(PowerMgrClientTest, PowerMgrClient007, TestSize.Level2) 217 { 218 POWER_HILOGI(LABEL_TEST, "PowerMgrClient007::fun is start!"); 219 uint32_t PARM_TWO = 2; 220 auto& powerMgrClient = PowerMgrClient::GetInstance(); 221 UserActivityType abnormaltype = UserActivityType(9); 222 223 powerMgrClient.SuspendDevice(); 224 // Wakeup Device before test 225 powerMgrClient.WakeupDevice(); 226 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient007: Prepare Fail, Screen is OFF."; 227 powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_WAIT_TIME_MS); 228 usleep(SCREEN_OFF_WAIT_TIME_S * TRANSFER_NS_TO_MS / PARM_TWO); 229 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient007: Prepare Fail, Screen is OFF."; 230 powerMgrClient.RefreshActivity(abnormaltype); 231 usleep(SCREEN_OFF_WAIT_TIME_S * TRANSFER_NS_TO_MS / PARM_TWO + WAIT_SUSPEND_TIME_MS * TRANSFER_MS_TO_S); 232 sleep(SCREEN_OFF_SLEEP_TIME_S); 233 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient007: RefreshActivity Device Fail, Screen is OFF"; 234 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 235 POWER_HILOGI(LABEL_TEST, "PowerMgrClient007::fun is end!"); 236 } 237 238 #ifdef HAS_DISPLAY_MANAGER_PART 239 /** 240 * @tc.name: PowerMgrClient008 241 * @tc.desc: test DISPLAY_DIM 242 * @tc.type: FUNC 243 * @tc.require: issueI5MJZJ 244 */ 245 HWTEST_F(PowerMgrClientTest, PowerMgrClient008, TestSize.Level2) 246 { 247 POWER_HILOGI(LABEL_TEST, "PowerMgrClient008::fun is start!"); 248 int64_t time = SCREEN_OFF_WAIT_TIME_MS; 249 auto& powerMgrClient = PowerMgrClient::GetInstance(); 250 auto& displayMgrClient = OHOS::DisplayPowerMgr::DisplayPowerMgrClient::GetInstance(); 251 252 powerMgrClient.OverrideScreenOffTime(time); 253 powerMgrClient.SuspendDevice(); 254 // Wakeup Device before test 255 powerMgrClient.WakeupDevice(); 256 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient008: Prepare Fail, Screen is OFF."; 257 usleep(time * TRANSFER_MS_TO_S * DIM_RATE); 258 // waiting for GetDimState time 259 usleep(DIM_STATE_WAIT_TIME_MS * TRANSFER_MS_TO_S); 260 auto ret = displayMgrClient.GetDisplayState(); 261 EXPECT_EQ(ret, DisplayPowerMgr::DisplayState::DISPLAY_DIM); 262 263 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 264 POWER_HILOGI(LABEL_TEST, "PowerMgrClient008::fun is end!"); 265 } 266 #endif 267 268 /** 269 * @tc.name: PowerMgrClient009 270 * @tc.desc: test WakeupDevice 271 * @tc.type: FUNC 272 * @tc.require: issueI5MJZJ 273 */ 274 HWTEST_F(PowerMgrClientTest, PowerMgrClient009, TestSize.Level0) 275 { 276 POWER_HILOGI(LABEL_TEST, "PowerMgrClient009::fun is start!"); 277 int32_t PARM_ONE = 1; 278 int32_t wakeupReason = (static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + PARM_ONE; 279 WakeupDeviceType abnormaltype = WakeupDeviceType(wakeupReason); 280 auto& powerMgrClient = PowerMgrClient::GetInstance(); 281 282 powerMgrClient.WakeupDevice(); 283 // Suspend Device before test 284 powerMgrClient.SuspendDevice(); 285 sleep(SLEEP_WAIT_TIME_S); 286 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient009: Prepare Fail, Screen is On."; 287 powerMgrClient.WakeupDevice(abnormaltype); 288 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient009: Wakeup Device Fail, Screen is Off"; 289 290 POWER_HILOGI(LABEL_TEST, "PowerMgrClient009::fun is end!"); 291 } 292 293 /** 294 * @tc.name: PowerMgrClient010 295 * @tc.desc: test Suspend Device 296 * @tc.type: FUNC 297 * @tc.require: issueI5MJZJ 298 */ 299 HWTEST_F(PowerMgrClientTest, PowerMgrClient010, TestSize.Level0) 300 { 301 POWER_HILOGI(LABEL_TEST, "PowerMgrClient010::fun is start!"); 302 int32_t PARM_ONE = 1; 303 auto& powerMgrClient = PowerMgrClient::GetInstance(); 304 int32_t suspendReason = (static_cast<int32_t>(SuspendDeviceType::SUSPEND_DEVICE_REASON_MAX)) + PARM_ONE; 305 SuspendDeviceType abnormaltype = SuspendDeviceType(suspendReason); 306 307 powerMgrClient.SuspendDevice(); 308 // Wakeup Device before test 309 powerMgrClient.WakeupDevice(); 310 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient010: Prepare Fail, Screen is OFF."; 311 powerMgrClient.SuspendDevice(abnormaltype, false); 312 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 313 314 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient010: Suspend Device Fail, Screen is On"; 315 POWER_HILOGI(LABEL_TEST, "PowerMgrClient010::fun is end!"); 316 } 317 318 #ifdef HAS_DISPLAY_MANAGER_PART 319 /** 320 * @tc.name: PowerMgrClient011 321 * @tc.desc: test auto suspend 322 * @tc.type: FUNC 323 * @tc.require: issueI5MJZJ 324 */ 325 HWTEST_F(PowerMgrClientTest, PowerMgrClient011, TestSize.Level2) 326 { 327 POWER_HILOGI(LABEL_TEST, "PowerMgrClient011::fun is start!"); 328 int32_t time = SET_DISPLAY_OFF_TIME_MS; 329 auto& powerMgrClient = PowerMgrClient::GetInstance(); 330 auto& displayMgrClient = OHOS::DisplayPowerMgr::DisplayPowerMgrClient::GetInstance(); 331 332 powerMgrClient.OverrideScreenOffTime(time); 333 powerMgrClient.SuspendDevice(); 334 // Wakeup Device before test 335 powerMgrClient.WakeupDevice(); 336 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient011: Prepare Fail, Screen is OFF."; 337 POWER_HILOGI(LABEL_TEST, "PowerMgrClient011::1!"); 338 usleep(time * TRANSFER_MS_TO_S * DIM_RATE); 339 // waiting for GetDimState time 340 usleep(DIM_STATE_WAIT_TIME_MS * TRANSFER_MS_TO_S); 341 auto ret = displayMgrClient.GetDisplayState(); 342 EXPECT_EQ(ret, DisplayPowerMgr::DisplayState::DISPLAY_DIM); 343 POWER_HILOGI(LABEL_TEST, "PowerMgrClient011::3!"); 344 usleep(time * TRANSFER_MS_TO_S * DIM_RATE + WAIT_SUSPEND_TIME_MS * TRANSFER_MS_TO_S); 345 POWER_HILOGI(LABEL_TEST, "PowerMgrClient011::8!"); 346 ret = displayMgrClient.GetDisplayState(); 347 EXPECT_EQ(ret, DisplayPowerMgr::DisplayState::DISPLAY_OFF); 348 349 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 350 POWER_HILOGI(LABEL_TEST, "PowerMgrClient011::fun is end!"); 351 } 352 #endif 353 354 /** 355 * @tc.name: PowerMgrClient012 356 * @tc.desc: test SCREEN_ON RunningLock 357 * @tc.type: FUNC 358 * @tc.require: issueI5MJZJ 359 */ 360 HWTEST_F(PowerMgrClientTest, PowerMgrClient012, TestSize.Level2) 361 { 362 POWER_HILOGI(LABEL_TEST, "PowerMgrClient012:Start."); 363 int32_t time = SET_DISPLAY_OFF_TIME_MS; 364 auto& powerMgrClient = PowerMgrClient::GetInstance(); 365 powerMgrClient.WakeupDevice(); 366 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient0012: Prepare Fail, Screen is OFF."; 367 auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN); 368 powerMgrClient.OverrideScreenOffTime(time); 369 runningLock->Lock(); 370 usleep(SLEEP_AFTER_LOCK_TIME_US); 371 EXPECT_EQ(runningLock->IsUsed(), true); 372 EXPECT_EQ(powerMgrClient.IsScreenOn(), true); 373 usleep(time * TRANSFER_MS_TO_S); 374 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 375 runningLock->UnLock(); 376 EXPECT_EQ(runningLock->IsUsed(), false); 377 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 378 POWER_HILOGI(LABEL_TEST, "PowerMgrClient012:End."); 379 } 380 381 /** 382 * @tc.name: PowerMgrClient013 383 * @tc.desc: test SCREEN_ON RunningLock 384 * @tc.type: FUNC 385 * @tc.require: issueI5MJZJ 386 */ 387 HWTEST_F(PowerMgrClientTest, PowerMgrClient013, TestSize.Level2) 388 { 389 POWER_HILOGI(LABEL_TEST, "PowerMgrClient013:Start."); 390 391 int32_t time = SET_DISPLAY_OFF_TIME_MS; 392 auto& powerMgrClient = PowerMgrClient::GetInstance(); 393 powerMgrClient.WakeupDevice(); 394 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient0013: Prepare Fail, Screen is OFF."; 395 auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN); 396 powerMgrClient.OverrideScreenOffTime(time); 397 398 runningLock->Lock(); 399 usleep(SLEEP_AFTER_LOCK_TIME_US); 400 EXPECT_EQ(runningLock->IsUsed(), true); 401 402 runningLock->UnLock(); 403 EXPECT_EQ(runningLock->IsUsed(), false); 404 usleep(time * TRANSFER_MS_TO_S + WAIT_SUSPEND_TIME_MS * TRANSFER_MS_TO_S); 405 EXPECT_EQ(powerMgrClient.IsScreenOn(), false); 406 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 407 POWER_HILOGI(LABEL_TEST, "PowerMgrClient013:End."); 408 } 409 410 /** 411 * @tc.name: PowerMgrClient014 412 * @tc.desc: test SCREEN_ON RunningLock 413 * @tc.type: FUNC 414 * @tc.require: issueI5MJZJ 415 */ 416 HWTEST_F(PowerMgrClientTest, PowerMgrClient014, TestSize.Level2) 417 { 418 POWER_HILOGI(LABEL_TEST, "PowerMgrClient014:Start."); 419 420 int32_t time = SET_DISPLAY_OFF_TIME_MS; 421 auto& powerMgrClient = PowerMgrClient::GetInstance(); 422 powerMgrClient.WakeupDevice(); 423 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient0014: Prepare Fail, Screen is OFF."; 424 auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN); 425 powerMgrClient.OverrideScreenOffTime(time); 426 427 runningLock->Lock(); 428 usleep(SLEEP_AFTER_LOCK_TIME_US); 429 EXPECT_EQ(runningLock->IsUsed(), true); 430 EXPECT_EQ(powerMgrClient.IsScreenOn(), true); 431 usleep(time * TRANSFER_MS_TO_S * DOUBLE_TIMES); 432 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 433 434 runningLock->UnLock(); 435 EXPECT_EQ(runningLock->IsUsed(), false); 436 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 437 POWER_HILOGI(LABEL_TEST, "PowerMgrClient014:End."); 438 } 439 440 /** 441 * @tc.name: PowerMgrClient015 442 * @tc.desc: test SCREEN_ON RunningLock 443 * @tc.type: FUNC 444 * @tc.require: issueI5MJZJ 445 */ 446 HWTEST_F(PowerMgrClientTest, PowerMgrClient015, TestSize.Level2) 447 { 448 POWER_HILOGI(LABEL_TEST, "PowerMgrClient015:Start."); 449 450 int32_t time = SET_DISPLAY_OFF_TIME_MS; 451 auto& powerMgrClient = PowerMgrClient::GetInstance(); 452 powerMgrClient.WakeupDevice(); 453 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient0015: Prepare Fail, Screen is OFF."; 454 auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN); 455 456 powerMgrClient.OverrideScreenOffTime(time); 457 458 runningLock->Lock(); 459 usleep(SLEEP_AFTER_LOCK_TIME_US); 460 EXPECT_EQ(runningLock->IsUsed(), true); 461 EXPECT_EQ(powerMgrClient.IsScreenOn(), true); 462 powerMgrClient.SuspendDevice(); 463 EXPECT_EQ(powerMgrClient.IsScreenOn(), false); 464 465 runningLock->UnLock(); 466 EXPECT_EQ(runningLock->IsUsed(), false); 467 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 468 POWER_HILOGI(LABEL_TEST, "PowerMgrClient015:End."); 469 } 470 471 /** 472 * @tc.name: PowerMgrClient016 473 * @tc.desc: test SCREEN_ON RunningLock 474 * @tc.type: FUNC 475 * @tc.require: issueI5MJZJ 476 */ 477 HWTEST_F(PowerMgrClientTest, PowerMgrClient016, TestSize.Level2) 478 { 479 POWER_HILOGI(LABEL_TEST, "PowerMgrClient016:Start."); 480 481 int32_t time = SET_DISPLAY_OFF_TIME_MS; 482 auto& powerMgrClient = PowerMgrClient::GetInstance(); 483 powerMgrClient.WakeupDevice(); 484 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient0016: Prepare Fail, Screen is OFF."; 485 auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN); 486 487 powerMgrClient.OverrideScreenOffTime(time); 488 489 runningLock->Lock(); 490 usleep(SLEEP_AFTER_LOCK_TIME_US + SLEEP_AFTER_LOCK_TIME_US); 491 EXPECT_EQ(runningLock->IsUsed(), true); 492 EXPECT_EQ(powerMgrClient.IsScreenOn(), true); 493 usleep(time * TRANSFER_MS_TO_S); 494 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 495 496 runningLock->UnLock(); 497 EXPECT_EQ(runningLock->IsUsed(), false); 498 powerMgrClient.OverrideScreenOffTime(PowerStateMachine::DEFAULT_SLEEP_TIME_MS); 499 POWER_HILOGI(LABEL_TEST, "PowerMgrClient016:End."); 500 } 501 502 /** 503 * @tc.name: PowerMgrClient017 504 * @tc.desc: test SetDisplaySuspend 505 * @tc.type: FUNC 506 * @tc.require: issueI5MJZJ 507 */ 508 HWTEST_F(PowerMgrClientTest, PowerMgrClient017, TestSize.Level2) 509 { 510 POWER_HILOGI(LABEL_TEST, "PowerMgrClient017::fun is start!"); 511 auto& powerMgrClient = PowerMgrClient::GetInstance(); 512 513 powerMgrClient.WakeupDevice(); 514 powerMgrClient.SuspendDevice(); 515 EXPECT_EQ(powerMgrClient.IsScreenOn(), false); 516 powerMgrClient.SetDisplaySuspend(true); 517 518 EXPECT_EQ(powerMgrClient.IsScreenOn(), false); 519 powerMgrClient.SetDisplaySuspend(false); 520 POWER_HILOGI(LABEL_TEST, "PowerMgrClient017::fun is end!"); 521 } 522 523 /** 524 * @tc.name: PowerMgrClient018 525 * @tc.desc: test Suspend Device in proxy 526 * @tc.type: FUNC 527 * @tc.require: issueI5MJZJ 528 */ 529 HWTEST_F(PowerMgrClientTest, PowerMgrClient018, TestSize.Level0) 530 { 531 POWER_HILOGI(LABEL_TEST, "PowerMgrClient018::fun is start!"); 532 auto& powerMgrClient = PowerMgrClient::GetInstance(); 533 534 powerMgrClient.SuspendDevice(); 535 // Wakeup Device before test 536 powerMgrClient.WakeupDevice(); 537 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient018: Prepare Fail, Screen is OFF."; 538 539 powerMgrClient.SuspendDevice(); 540 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient018: Suspend Device Fail, Screen is On"; 541 542 POWER_HILOGI(LABEL_TEST, "PowerMgrClient018::fun is end!"); 543 } 544 545 /** 546 * @tc.name: PowerMgrClient019 547 * @tc.desc: test Suspend Device 548 * @tc.type: FUNC 549 * @tc.require: issueI5MJZJ 550 */ 551 HWTEST_F(PowerMgrClientTest, PowerMgrClient019, TestSize.Level0) 552 { 553 POWER_HILOGI(LABEL_TEST, "PowerMgrClient019::fun is start!"); 554 auto& powerMgrClient = PowerMgrClient::GetInstance(); 555 556 powerMgrClient.SuspendDevice(); 557 // Wakeup Device before test 558 powerMgrClient.WakeupDevice(); 559 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient019: Prepare Fail, Screen is OFF."; 560 561 powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false); 562 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient019: Suspend Device Fail, Screen is On"; 563 564 POWER_HILOGI(LABEL_TEST, "PowerMgrClient019::fun is end!"); 565 } 566 567 /** 568 * @tc.name: PowerMgrClient020 569 * @tc.desc: test Suspend Device 570 * @tc.type: FUNC 571 * @tc.require: issueI5MJZJ 572 */ 573 HWTEST_F(PowerMgrClientTest, PowerMgrClient020, TestSize.Level0) 574 { 575 POWER_HILOGI(LABEL_TEST, "PowerMgrClient020::fun is start!"); 576 auto& powerMgrClient = PowerMgrClient::GetInstance(); 577 578 powerMgrClient.SuspendDevice(); 579 // Wakeup Device before test 580 powerMgrClient.WakeupDevice(); 581 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient020: Prepare Fail, Screen is OFF."; 582 583 powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false); 584 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient020: Suspend Device Fail, Screen is On"; 585 586 POWER_HILOGI(LABEL_TEST, "PowerMgrClient020::fun is end!"); 587 } 588 589 /** 590 * @tc.name: PowerMgrClient021 591 * @tc.desc: test Suspend Device 592 * @tc.type: FUNC 593 * @tc.require: issueI5MJZJ 594 */ 595 HWTEST_F(PowerMgrClientTest, PowerMgrClient021, TestSize.Level0) 596 { 597 POWER_HILOGI(LABEL_TEST, "PowerMgrClient021::fun is start!"); 598 auto& powerMgrClient = PowerMgrClient::GetInstance(); 599 600 powerMgrClient.SuspendDevice(); 601 // Wakeup Device before test 602 powerMgrClient.WakeupDevice(); 603 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient021: Prepare Fail, Screen is OFF."; 604 605 powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_LID, false); 606 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient021: Suspend Device Fail, Screen is On"; 607 608 POWER_HILOGI(LABEL_TEST, "PowerMgrClient021::fun is end!"); 609 } 610 611 /** 612 * @tc.name: PowerMgrClient022 613 * @tc.desc: test Suspend Device 614 * @tc.type: FUNC 615 * @tc.require: issueI5MJZJ 616 */ 617 HWTEST_F(PowerMgrClientTest, PowerMgrClient022, TestSize.Level0) 618 { 619 POWER_HILOGI(LABEL_TEST, "PowerMgrClient022::fun is start!"); 620 auto& powerMgrClient = PowerMgrClient::GetInstance(); 621 622 powerMgrClient.SuspendDevice(); 623 // Wakeup Device before test 624 powerMgrClient.WakeupDevice(); 625 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient022: Prepare Fail, Screen is OFF."; 626 627 powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY, false); 628 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient022: Suspend Device Fail, Screen is On"; 629 630 POWER_HILOGI(LABEL_TEST, "PowerMgrClient022::fun is end!"); 631 } 632 633 /** 634 * @tc.name: PowerMgrClient023 635 * @tc.desc: test Suspend Device 636 * @tc.type: FUNC 637 * @tc.require: issueI5MJZJ 638 */ 639 HWTEST_F(PowerMgrClientTest, PowerMgrClient023, TestSize.Level0) 640 { 641 POWER_HILOGI(LABEL_TEST, "PowerMgrClient023::fun is start!"); 642 auto& powerMgrClient = PowerMgrClient::GetInstance(); 643 644 powerMgrClient.SuspendDevice(); 645 // Wakeup Device before test 646 powerMgrClient.WakeupDevice(); 647 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient023: Prepare Fail, Screen is OFF."; 648 649 powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI, false); 650 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient023: Suspend Device Fail, Screen is On"; 651 652 POWER_HILOGI(LABEL_TEST, "PowerMgrClient023::fun is end!"); 653 } 654 655 /** 656 * @tc.name: PowerMgrClient024 657 * @tc.desc: test Suspend Device 658 * @tc.type: FUNC 659 * @tc.require: issueI5MJZJ 660 */ 661 HWTEST_F(PowerMgrClientTest, PowerMgrClient024, TestSize.Level0) 662 { 663 POWER_HILOGI(LABEL_TEST, "PowerMgrClient024::fun is start!"); 664 auto& powerMgrClient = PowerMgrClient::GetInstance(); 665 666 powerMgrClient.SuspendDevice(); 667 // Wakeup Device before test 668 powerMgrClient.WakeupDevice(); 669 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient024: Prepare Fail, Screen is OFF."; 670 671 powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_KEY, false); 672 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient024: Suspend Device Fail, Screen is On"; 673 674 POWER_HILOGI(LABEL_TEST, "PowerMgrClient024::fun is end!"); 675 } 676 677 /** 678 * @tc.name: PowerMgrClient025 679 * @tc.desc: test Suspend Device 680 * @tc.type: FUNC 681 * @tc.require: issueI5MJZJ 682 */ 683 HWTEST_F(PowerMgrClientTest, PowerMgrClient025, TestSize.Level0) 684 { 685 POWER_HILOGI(LABEL_TEST, "PowerMgrClient025::fun is start!"); 686 auto& powerMgrClient = PowerMgrClient::GetInstance(); 687 688 powerMgrClient.SuspendDevice(); 689 // Wakeup Device before test 690 powerMgrClient.WakeupDevice(); 691 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient025: Prepare Fail, Screen is OFF."; 692 693 powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY, false); 694 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient025: Suspend Device Fail, Screen is On"; 695 696 POWER_HILOGI(LABEL_TEST, "PowerMgrClient025::fun is end!"); 697 } 698 699 /** 700 * @tc.name: PowerMgrClient026 701 * @tc.desc: test Suspend Device 702 * @tc.type: FUNC 703 * @tc.require: issueI5MJZJ 704 */ 705 HWTEST_F(PowerMgrClientTest, PowerMgrClient026, TestSize.Level0) 706 { 707 POWER_HILOGI(LABEL_TEST, "PowerMgrClient026::fun is start!"); 708 auto& powerMgrClient = PowerMgrClient::GetInstance(); 709 710 powerMgrClient.SuspendDevice(); 711 // Wakeup Device before test 712 powerMgrClient.WakeupDevice(); 713 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient026: Prepare Fail, Screen is OFF."; 714 715 powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND, false); 716 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient026: Suspend Device Fail, Screen is On"; 717 718 POWER_HILOGI(LABEL_TEST, "PowerMgrClient026::fun is end!"); 719 } 720 721 /** 722 * @tc.name: PowerMgrClient027 723 * @tc.desc: test WakeupDevice(int64_t timeMs) in proxy 724 * @tc.type: FUNC 725 * @tc.require: issueI5MJZJ 726 */ 727 HWTEST_F(PowerMgrClientTest, PowerMgrClient027, TestSize.Level0) 728 { 729 POWER_HILOGI(LABEL_TEST, "PowerMgrClient027::fun is start!"); 730 auto& powerMgrClient = PowerMgrClient::GetInstance(); 731 732 powerMgrClient.WakeupDevice(); 733 // Suspend Device before test 734 powerMgrClient.SuspendDevice(); 735 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient027: Prepare Fail, Screen is On."; 736 737 powerMgrClient.WakeupDevice(); 738 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 739 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient027: Wakeup Device Fail, Screen is Off"; 740 741 POWER_HILOGI(LABEL_TEST, "PowerMgrClient027::fun is end!"); 742 } 743 744 /** 745 * @tc.name: PowerMgrClient028 746 * @tc.desc: test WakeupDevice 747 * @tc.type: FUNC 748 * @tc.require: issueI5MJZJ 749 */ 750 HWTEST_F(PowerMgrClientTest, PowerMgrClient028, TestSize.Level0) 751 { 752 POWER_HILOGI(LABEL_TEST, "PowerMgrClient028::fun is start!"); 753 auto& powerMgrClient = PowerMgrClient::GetInstance(); 754 755 powerMgrClient.WakeupDevice(); 756 // Suspend Device before test 757 powerMgrClient.SuspendDevice(); 758 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient028: Prepare Fail, Screen is On."; 759 760 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN); 761 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 762 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient028: Wakeup Device Fail, Screen is Off"; 763 764 POWER_HILOGI(LABEL_TEST, "PowerMgrClient028::fun is end!"); 765 } 766 767 /** 768 * @tc.name: PowerMgrClient029 769 * @tc.desc: test WakeupDevice 770 * @tc.type: FUNC 771 * @tc.require: issueI5MJZJ 772 */ 773 HWTEST_F(PowerMgrClientTest, PowerMgrClient029, TestSize.Level0) 774 { 775 POWER_HILOGI(LABEL_TEST, "PowerMgrClient029::fun is start!"); 776 auto& powerMgrClient = PowerMgrClient::GetInstance(); 777 778 powerMgrClient.WakeupDevice(); 779 // Suspend Device before test 780 powerMgrClient.SuspendDevice(); 781 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient029: Prepare Fail, Screen is On."; 782 783 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON); 784 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 785 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient029: Wakeup Device Fail, Screen is Off"; 786 787 POWER_HILOGI(LABEL_TEST, "PowerMgrClient029::fun is end!"); 788 } 789 790 /** 791 * @tc.name: PowerMgrClient030 792 * @tc.desc: test WakeupDevice 793 * @tc.type: FUNC 794 * @tc.require: issueI5MJZJ 795 */ 796 HWTEST_F(PowerMgrClientTest, PowerMgrClient030, TestSize.Level0) 797 { 798 POWER_HILOGI(LABEL_TEST, "PowerMgrClient030::fun is start!"); 799 auto& powerMgrClient = PowerMgrClient::GetInstance(); 800 801 powerMgrClient.WakeupDevice(); 802 // Suspend Device before test 803 powerMgrClient.SuspendDevice(); 804 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient030: Prepare Fail, Screen is On."; 805 806 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN); 807 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 808 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient030: Wakeup Device Fail, Screen is Off"; 809 810 POWER_HILOGI(LABEL_TEST, "PowerMgrClient030::fun is end!"); 811 } 812 813 /** 814 * @tc.name: PowerMgrClient031 815 * @tc.desc: test WakeupDevice 816 * @tc.type: FUNC 817 * @tc.require: issueI5MJZJ 818 */ 819 HWTEST_F(PowerMgrClientTest, PowerMgrClient031, TestSize.Level0) 820 { 821 POWER_HILOGI(LABEL_TEST, "PowerMgrClient031::fun is start!"); 822 auto& powerMgrClient = PowerMgrClient::GetInstance(); 823 824 powerMgrClient.WakeupDevice(); 825 // Suspend Device before test 826 powerMgrClient.SuspendDevice(); 827 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient031: Prepare Fail, Screen is On."; 828 829 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_GESTURE); 830 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 831 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient031: Wakeup Device Fail, Screen is Off"; 832 833 POWER_HILOGI(LABEL_TEST, "PowerMgrClient031::fun is end!"); 834 } 835 836 /** 837 * @tc.name: PowerMgrClient032 838 * @tc.desc: test WakeupDevice 839 * @tc.type: FUNC 840 * @tc.require: issueI5MJZJ 841 */ 842 HWTEST_F(PowerMgrClientTest, PowerMgrClient032, TestSize.Level0) 843 { 844 POWER_HILOGI(LABEL_TEST, "PowerMgrClient032::fun is start!"); 845 auto& powerMgrClient = PowerMgrClient::GetInstance(); 846 847 powerMgrClient.WakeupDevice(); 848 // Suspend Device before test 849 powerMgrClient.SuspendDevice(); 850 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient032: Prepare Fail, Screen is On."; 851 852 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH); 853 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 854 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient032: Wakeup Device Fail, Screen is Off"; 855 856 POWER_HILOGI(LABEL_TEST, "PowerMgrClient032::fun is end!"); 857 } 858 859 /** 860 * @tc.name: PowerMgrClient033 861 * @tc.desc: test WakeupDevice 862 * @tc.type: FUNC 863 * @tc.require: issueI5MJZJ 864 */ 865 HWTEST_F(PowerMgrClientTest, PowerMgrClient033, TestSize.Level0) 866 { 867 POWER_HILOGI(LABEL_TEST, "PowerMgrClient033::fun is start!"); 868 auto& powerMgrClient = PowerMgrClient::GetInstance(); 869 870 powerMgrClient.WakeupDevice(); 871 // Suspend Device before test 872 powerMgrClient.SuspendDevice(); 873 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient033: Prepare Fail, Screen is On."; 874 875 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY); 876 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 877 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient033: Wakeup Device Fail, Screen is Off"; 878 879 POWER_HILOGI(LABEL_TEST, "PowerMgrClient033::fun is end!"); 880 } 881 882 /** 883 * @tc.name: PowerMgrClient034 884 * @tc.desc: test WakeupDevice 885 * @tc.type: FUNC 886 * @tc.require: issueI5MJZJ 887 */ 888 HWTEST_F(PowerMgrClientTest, PowerMgrClient034, TestSize.Level0) 889 { 890 POWER_HILOGI(LABEL_TEST, "PowerMgrClient034::fun is start!"); 891 auto& powerMgrClient = PowerMgrClient::GetInstance(); 892 893 powerMgrClient.WakeupDevice(); 894 // Suspend Device before test 895 powerMgrClient.SuspendDevice(); 896 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient034: Prepare Fail, Screen is On."; 897 898 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION); 899 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 900 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient034: Wakeup Device Fail, Screen is Off"; 901 902 POWER_HILOGI(LABEL_TEST, "PowerMgrClient034::fun is end!"); 903 } 904 905 /** 906 * @tc.name: PowerMgrClient035 907 * @tc.desc: test WakeupDevice 908 * @tc.type: FUNC 909 * @tc.require: issueI5MJZJ 910 */ 911 HWTEST_F(PowerMgrClientTest, PowerMgrClient035, TestSize.Level0) 912 { 913 POWER_HILOGI(LABEL_TEST, "PowerMgrClient035::fun is start!"); 914 auto& powerMgrClient = PowerMgrClient::GetInstance(); 915 916 powerMgrClient.WakeupDevice(); 917 // Suspend Device before test 918 powerMgrClient.SuspendDevice(); 919 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient035: Prepare Fail, Screen is On."; 920 921 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_HDMI); 922 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 923 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient035: Wakeup Device Fail, Screen is Off"; 924 925 POWER_HILOGI(LABEL_TEST, "PowerMgrClient035::fun is end!"); 926 } 927 928 /** 929 * @tc.name: PowerMgrClient036 930 * @tc.desc: test WakeupDevice 931 * @tc.type: FUNC 932 * @tc.require: issueI5MJZJ 933 */ 934 HWTEST_F(PowerMgrClientTest, PowerMgrClient036, TestSize.Level0) 935 { 936 POWER_HILOGI(LABEL_TEST, "PowerMgrClient036::fun is start!"); 937 auto& powerMgrClient = PowerMgrClient::GetInstance(); 938 939 powerMgrClient.WakeupDevice(); 940 // Suspend Device before test 941 powerMgrClient.SuspendDevice(); 942 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient036: Prepare Fail, Screen is On."; 943 944 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_LID); 945 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 946 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient036: Wakeup Device Fail, Screen is Off"; 947 948 POWER_HILOGI(LABEL_TEST, "PowerMgrClient036::fun is end!"); 949 } 950 951 /** 952 * @tc.name: PowerMgrClient037 953 * @tc.desc: test WakeupDevice 954 * @tc.type: FUNC 955 * @tc.require: issueI5MJZJ 956 */ 957 HWTEST_F(PowerMgrClientTest, PowerMgrClient037, TestSize.Level0) 958 { 959 POWER_HILOGI(LABEL_TEST, "PowerMgrClient037::fun is start!"); 960 auto& powerMgrClient = PowerMgrClient::GetInstance(); 961 962 powerMgrClient.WakeupDevice(); 963 // Suspend Device before test 964 powerMgrClient.SuspendDevice(); 965 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient037: Prepare Fail, Screen is On."; 966 967 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK); 968 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 969 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient037: Wakeup Device Fail, Screen is Off"; 970 971 POWER_HILOGI(LABEL_TEST, "PowerMgrClient037::fun is end!"); 972 } 973 974 /** 975 * @tc.name: PowerMgrClient038 976 * @tc.desc: test WakeupDevice 977 * @tc.type: FUNC 978 * @tc.require: issueI5MJZJ 979 */ 980 HWTEST_F(PowerMgrClientTest, PowerMgrClient038, TestSize.Level0) 981 { 982 POWER_HILOGI(LABEL_TEST, "PowerMgrClient038::fun is start!"); 983 auto& powerMgrClient = PowerMgrClient::GetInstance(); 984 985 powerMgrClient.WakeupDevice(); 986 // Suspend Device before test 987 powerMgrClient.SuspendDevice(); 988 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient038: Prepare Fail, Screen is On."; 989 990 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD); 991 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 992 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient038: Wakeup Device Fail, Screen is Off"; 993 994 POWER_HILOGI(LABEL_TEST, "PowerMgrClient038::fun is end!"); 995 } 996 997 /** 998 * @tc.name: PowerMgrClient039 999 * @tc.desc: test WakeupDevice 1000 * @tc.type: FUNC 1001 * @tc.require: issueI5MJZJ 1002 */ 1003 HWTEST_F(PowerMgrClientTest, PowerMgrClient039, TestSize.Level0) 1004 { 1005 POWER_HILOGI(LABEL_TEST, "PowerMgrClient039::fun is start!"); 1006 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1007 1008 powerMgrClient.WakeupDevice(); 1009 // Suspend Device before test 1010 powerMgrClient.SuspendDevice(); 1011 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient039: Prepare Fail, Screen is On."; 1012 1013 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_MOUSE); 1014 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 1015 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient039: Wakeup Device Fail, Screen is Off"; 1016 1017 POWER_HILOGI(LABEL_TEST, "PowerMgrClient039::fun is end!"); 1018 } 1019 1020 /** 1021 * @tc.name: PowerMgrClient040 1022 * @tc.desc: test IsRunningLockTypeSupported 1023 * @tc.type: FUNC 1024 * @tc.require: issueI5MJZJ 1025 */ 1026 HWTEST_F(PowerMgrClientTest, PowerMgrClient040, TestSize.Level0) 1027 { 1028 POWER_HILOGI(LABEL_TEST, "PowerMgrClient040:Start."); 1029 1030 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1031 auto ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BUTT); 1032 EXPECT_EQ(ret, false); 1033 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_SCREEN); 1034 EXPECT_EQ(ret, true); 1035 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BACKGROUND); 1036 EXPECT_EQ(ret, true); 1037 #ifdef HAS_SENSORS_SENSOR_PART 1038 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); 1039 EXPECT_EQ(ret, true); 1040 #endif 1041 powerMgrClient.WakeupDevice(); 1042 EXPECT_EQ(powerMgrClient.IsScreenOn(), true); 1043 powerMgrClient.SuspendDevice(); 1044 EXPECT_EQ(powerMgrClient.IsScreenOn(), false); 1045 1046 POWER_HILOGI(LABEL_TEST, "PowerMgrClient040:End."); 1047 } 1048 1049 /** 1050 * @tc.name: PowerMgrClient041 1051 * @tc.desc: Test GetError 1052 * @tc.type: FUNC 1053 * @tc.require: issue I5YZQR 1054 */ 1055 HWTEST_F(PowerMgrClientTest, PowerMgrClient041, TestSize.Level0) 1056 { 1057 POWER_HILOGI(LABEL_TEST, "PowerMgrClient041 is start"); 1058 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1059 PowerErrors error = powerMgrClient.GetError(); 1060 POWER_HILOGI(LABEL_TEST, "get error %{public}d", static_cast<int32_t>(error)); 1061 EXPECT_TRUE(error == PowerErrors::ERR_OK); 1062 POWER_HILOGI(LABEL_TEST, "PowerMgrClient041 is end"); 1063 } 1064 1065 /** 1066 * @tc.name: PowerMgrClient042 1067 * @tc.desc: test IsRunningLockTypeSupported for BACKGROUND lock types 1068 * @tc.type: FUNC 1069 * @tc.require: issueI6FMHX 1070 */ 1071 HWTEST_F(PowerMgrClientTest, PowerMgrClient042, TestSize.Level0) 1072 { 1073 POWER_HILOGI(LABEL_TEST, "PowerMgrClient042:Start."); 1074 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1075 auto ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE); 1076 EXPECT_EQ(ret, true); 1077 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION); 1078 EXPECT_EQ(ret, true); 1079 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO); 1080 EXPECT_EQ(ret, true); 1081 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT); 1082 EXPECT_EQ(ret, true); 1083 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION); 1084 EXPECT_EQ(ret, true); 1085 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BACKGROUND_TASK); 1086 EXPECT_EQ(ret, true); 1087 ret = powerMgrClient.IsRunningLockTypeSupported(RunningLockType::RUNNINGLOCK_BUTT); 1088 EXPECT_EQ(ret, false); 1089 POWER_HILOGI(LABEL_TEST, "PowerMgrClient042:End."); 1090 } 1091 1092 /** 1093 * @tc.name: PowerMgrClient043 1094 * @tc.desc: test WakeupDevice 1095 * @tc.type: FUNC 1096 * @tc.require: issueI5MJZJ 1097 */ 1098 HWTEST_F(PowerMgrClientTest, PowerMgrClient043, TestSize.Level0) 1099 { 1100 POWER_HILOGI(LABEL_TEST, "PowerMgrClient043::fun is start!"); 1101 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1102 1103 powerMgrClient.WakeupDevice(); 1104 // Suspend Device before test 1105 powerMgrClient.SuspendDevice(); 1106 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient043: Prepare Fail, Screen is On."; 1107 1108 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION); 1109 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 1110 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient043: Wakeup Device Fail, Screen is Off"; 1111 1112 POWER_HILOGI(LABEL_TEST, "PowerMgrClient043::fun is end!"); 1113 } 1114 1115 /** 1116 * @tc.name: PowerMgrClient044 1117 * @tc.desc: test WakeupDevice 1118 * @tc.type: FUNC 1119 * @tc.require: #I9G5XH 1120 */ 1121 HWTEST_F(PowerMgrClientTest, PowerMgrClient044, TestSize.Level0) 1122 { 1123 POWER_HILOGI(LABEL_TEST, "PowerMgrClient044::fun is start!"); 1124 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1125 1126 powerMgrClient.WakeupDevice(); 1127 // Suspend Device before test 1128 powerMgrClient.SuspendDevice(); 1129 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient044: Prepare Fail, Screen is On."; 1130 1131 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_AOD_SLIDING); 1132 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 1133 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient044: Wakeup Device Fail, Screen is Off"; 1134 1135 POWER_HILOGI(LABEL_TEST, "PowerMgrClient044::fun is end!"); 1136 } 1137 1138 /** 1139 * @tc.name: PowerMgrClient045 1140 * @tc.desc: test SetIgnoreScreenOnLock 1141 * @tc.type: FUNC 1142 * @tc.require: issueI96FJ5 1143 */ 1144 HWTEST_F(PowerMgrClientTest, PowerMgrClient045, TestSize.Level0) 1145 { 1146 POWER_HILOGI(LABEL_TEST, "PowerMgrClient045::func started!"); 1147 uint32_t PARM_ONE = 1; 1148 int32_t time = SET_DISPLAY_OFF_TIME_MS; 1149 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1150 //the last testcase aka WAKEUP_DEVICE_AOD_SLIDING unlocks screen as well. 1151 //thus the screen off time will be restored thereafter. 1152 //in case the screen turns off cause of time-out, we don't want screen-lock to override screen-off-time 1153 auto ret = powerMgrClient.LockScreenAfterTimingOut(false, false); 1154 EXPECT_EQ(ret, PowerErrors::ERR_OK); 1155 sleep(PARM_ONE); // wait for screen lock to restore the overrriden screen-off time after AOD_SLIDING. 1156 //everything should be fine now, no more interference from screen-lock 1157 powerMgrClient.WakeupDevice(); 1158 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient045: Prepare Fail, Screen is OFF."; 1159 auto runningLock = powerMgrClient.CreateRunningLock("runninglock", RunningLockType::RUNNINGLOCK_SCREEN); 1160 powerMgrClient.OverrideScreenOffTime(time); 1161 runningLock->Lock(); 1162 usleep(time * TRANSFER_MS_TO_S + WAIT_SUSPEND_TIME_MS * TRANSFER_MS_TO_S); 1163 EXPECT_EQ(powerMgrClient.IsScreenOn(), true); 1164 ret = powerMgrClient.SetForceTimingOut(true); 1165 EXPECT_EQ(ret, PowerErrors::ERR_OK); 1166 usleep(time * TRANSFER_MS_TO_S + WAIT_SUSPEND_TIME_MS * TRANSFER_MS_TO_S); 1167 EXPECT_EQ(powerMgrClient.IsScreenOn(), false); 1168 powerMgrClient.SetForceTimingOut(false); 1169 powerMgrClient.WakeupDevice(); 1170 EXPECT_EQ(powerMgrClient.IsScreenOn(), true); 1171 usleep(time * TRANSFER_MS_TO_S + WAIT_SUSPEND_TIME_MS * TRANSFER_MS_TO_S); 1172 EXPECT_EQ(powerMgrClient.IsScreenOn(), true); 1173 ret = powerMgrClient.LockScreenAfterTimingOut(true, false); // reset 1174 EXPECT_EQ(ret, PowerErrors::ERR_OK); 1175 POWER_HILOGI(LABEL_TEST, "PowerMgrClient045::func ended!"); 1176 } 1177 1178 /** 1179 * @tc.name: PowerMgrClient046 1180 * @tc.desc: test hibernate 1181 * @tc.type: FUNC 1182 * @tc.require: issueI5MJZJ 1183 */ 1184 #ifndef POWER_MANAGER_POWER_ENABLE_S4 1185 HWTEST_F(PowerMgrClientTest, PowerMgrClient046, TestSize.Level0) 1186 { 1187 POWER_HILOGI(LABEL_TEST, "PowerMgrClient046::fun is start!"); 1188 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1189 PowerErrors ret = powerMgrClient.Hibernate(true); 1190 EXPECT_EQ(ret, PowerErrors::ERR_FAILURE); 1191 POWER_HILOGI(LABEL_TEST, "PowerMgrClient046::fun is end!"); 1192 } 1193 1194 /** 1195 * @tc.name: PowerMgrClient047 1196 * @tc.desc: test hibernate 1197 * @tc.type: FUNC 1198 * @tc.require: issueI5MJZJ 1199 */ 1200 HWTEST_F(PowerMgrClientTest, PowerMgrClient047, TestSize.Level0) 1201 { 1202 POWER_HILOGI(LABEL_TEST, "PowerMgrClient047::fun is start!"); 1203 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1204 PowerErrors ret = powerMgrClient.Hibernate(false); 1205 EXPECT_EQ(ret, PowerErrors::ERR_FAILURE); 1206 POWER_HILOGI(LABEL_TEST, "PowerMgrClient047::fun is end!"); 1207 } 1208 #endif 1209 1210 /** 1211 * @tc.name: PowerMgrClient048 1212 * @tc.desc: test for coverage 1213 * @tc.type: FUNC 1214 */ 1215 HWTEST_F(PowerMgrClientTest, PowerMgrClient048, TestSize.Level0) 1216 { 1217 POWER_HILOGI(LABEL_TEST, "PowerMgrClient048::fun is start!"); 1218 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1219 std::shared_ptr<RunningLock> testLock = 1220 powerMgrClient.CreateRunningLock("testLock", RunningLockType::RUNNINGLOCK_SCREEN); 1221 ASSERT_TRUE(!testLock->IsUsed()); 1222 testLock->Lock(); 1223 ASSERT_TRUE(testLock->IsUsed()); 1224 pid_t curUid = getuid(); 1225 pid_t curPid = getpid(); 1226 EXPECT_TRUE(powerMgrClient.ProxyRunningLock(true, curPid, curUid)); 1227 ASSERT_TRUE(!testLock->IsUsed()); 1228 EXPECT_TRUE(powerMgrClient.ProxyRunningLock(false, curPid, curUid)); 1229 ASSERT_TRUE(testLock->IsUsed()); 1230 testLock->UnLock(); 1231 testLock->Recover(nullptr); 1232 POWER_HILOGI(LABEL_TEST, "PowerMgrClient048::fun is end!"); 1233 } 1234 1235 /** 1236 * @tc.name: PowerMgrClient049 1237 * @tc.desc: test WakeupDevice 1238 * @tc.type: FUNC 1239 * @tc.require: #I9O7I2 1240 */ 1241 HWTEST_F(PowerMgrClientTest, PowerMgrClient049, TestSize.Level0) 1242 { 1243 POWER_HILOGI(LABEL_TEST, "PowerMgrClient049::fun is start!"); 1244 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1245 1246 powerMgrClient.WakeupDevice(); 1247 // Suspend Device before test 1248 powerMgrClient.SuspendDevice(); 1249 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient049: Prepare Fail, Screen is On."; 1250 1251 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_PEN); 1252 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 1253 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient049: Wakeup Device Fail, Screen is Off"; 1254 1255 POWER_HILOGI(LABEL_TEST, "PowerMgrClient049::fun is end!"); 1256 } 1257 1258 /** 1259 * @tc.name: PowerMgrClient050 1260 * @tc.desc: test SetSuspendTag 1261 * @tc.type: FUNC 1262 * @tc.require: #I9TKSX 1263 */ 1264 HWTEST_F(PowerMgrClientTest, PowerMgrClient050, TestSize.Level0) 1265 { 1266 POWER_HILOGI(LABEL_TEST, "PowerMgrClient050::fun is start!"); 1267 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1268 EXPECT_EQ(powerMgrClient.SetSuspendTag("ulsr"), PowerErrors::ERR_OK); 1269 POWER_HILOGI(LABEL_TEST, "PowerMgrClient050::fun is end!"); 1270 } 1271 1272 /** 1273 * @tc.name: PowerMgrClient051 1274 * @tc.desc: test IsFoldScreenOn 1275 * @tc.type: FUNC 1276 * @tc.require: #I9UWD0 1277 */ 1278 HWTEST_F(PowerMgrClientTest, PowerMgrClient051, TestSize.Level0) 1279 { 1280 POWER_HILOGI(LABEL_TEST, "PowerMgrClient051::fun is start!"); 1281 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1282 1283 powerMgrClient.WakeupDevice(); 1284 1285 // Suspend Device before test 1286 powerMgrClient.SuspendDevice(); 1287 EXPECT_EQ(powerMgrClient.IsFoldScreenOn(), false) << "PowerMgrClient051: Screen is Off"; 1288 1289 powerMgrClient.WakeupDevice(); 1290 EXPECT_EQ(powerMgrClient.IsFoldScreenOn(), true) << "PowerMgrClient051: Screen is On"; 1291 1292 POWER_HILOGI(LABEL_TEST, "PowerMgrClient051::fun is end!"); 1293 } 1294 1295 /** 1296 * @tc.name: PowerMgrClient052 1297 * @tc.desc: test RegisterSyncHibernateCallback 1298 * @tc.type: FUNC 1299 * @tc.require: issueI5MJZJ 1300 */ 1301 HWTEST_F(PowerMgrClientTest, PowerMgrClient052, TestSize.Level0) 1302 { 1303 POWER_HILOGI(LABEL_TEST, "PowerMgrClient052::fun is start!"); 1304 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1305 bool ret = powerMgrClient.RegisterSyncHibernateCallback(nullptr); 1306 // parameter is nullptr 1307 EXPECT_FALSE(ret); 1308 POWER_HILOGI(LABEL_TEST, "PowerMgrClient052::fun is end!"); 1309 } 1310 1311 /** 1312 * @tc.name: PowerMgrClient053 1313 * @tc.desc: test unRegisterSyncHibernateCallback 1314 * @tc.type: FUNC 1315 * @tc.require: issueI5MJZJ 1316 */ 1317 HWTEST_F(PowerMgrClientTest, PowerMgrClient053, TestSize.Level0) 1318 { 1319 POWER_HILOGI(LABEL_TEST, "PowerMgrClient053::fun is start!"); 1320 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1321 bool ret = powerMgrClient.UnRegisterSyncHibernateCallback(nullptr); 1322 EXPECT_FALSE(ret); 1323 POWER_HILOGI(LABEL_TEST, "PowerMgrClient053::fun is end!"); 1324 } 1325 1326 /** 1327 * @tc.name: PowerMgrClient054 1328 * @tc.desc: test IsCollaborationScreenOn 1329 * @tc.type: FUNC 1330 * @tc.require: #IAN4ZA 1331 */ 1332 HWTEST_F(PowerMgrClientTest, PowerMgrClient054, TestSize.Level0) 1333 { 1334 POWER_HILOGI(LABEL_TEST, "PowerMgrClient054::fun is start!"); 1335 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1336 1337 powerMgrClient.WakeupDevice(); 1338 1339 // Suspend Device before test 1340 powerMgrClient.SuspendDevice(); 1341 EXPECT_EQ(powerMgrClient.IsCollaborationScreenOn(), false) << "PowerMgrClient054: Screen is Off"; 1342 1343 powerMgrClient.WakeupDevice(); 1344 EXPECT_EQ(powerMgrClient.IsCollaborationScreenOn(), true) << "PowerMgrClient054: Screen is On"; 1345 1346 POWER_HILOGI(LABEL_TEST, "PowerMgrClient054::fun is end!"); 1347 } 1348 1349 /** 1350 * @tc.name: PowerMgrClient055 1351 * @tc.desc: test WakeupDevice 1352 * @tc.type: FUNC 1353 * @tc.require: #IAXR0O 1354 */ 1355 HWTEST_F(PowerMgrClientTest, PowerMgrClient055, TestSize.Level0) 1356 { 1357 POWER_HILOGI(LABEL_TEST, "PowerMgrClient055::fun is start!"); 1358 uint32_t PARM_ONE = 1; 1359 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1360 1361 powerMgrClient.WakeupDevice(); 1362 // Suspend Device before test 1363 powerMgrClient.SuspendDevice(); 1364 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrClient055: Prepare Fail, Screen is On."; 1365 1366 powerMgrClient.WakeupDeviceAsync(WakeupDeviceType::WAKEUP_DEVICE_PEN); 1367 sleep(PARM_ONE); 1368 EXPECT_EQ(powerMgrClient.GetState(), PowerState::AWAKE); 1369 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrClient055: Wakeup Device Async Fail, Screen is Off"; 1370 1371 POWER_HILOGI(LABEL_TEST, "PowerMgrClient055::fun is end!"); 1372 } 1373 1374 /** 1375 * @tc.name: PowerMgrClient056 1376 * @tc.desc: test IsRunningLockEnabled 1377 * @tc.type: FUNC 1378 * @tc.require: #IBADHF 1379 */ 1380 HWTEST_F(PowerMgrClientTest, PowerMgrClient056, TestSize.Level0) 1381 { 1382 POWER_HILOGD(LABEL_TEST, "PowerMgrClient056::fun is start!"); 1383 auto& powerMgrClient = PowerMgrClient::GetInstance(); 1384 auto runningLock = powerMgrClient.CreateRunningLock("runninglockScreen", RunningLockType::RUNNINGLOCK_SCREEN); 1385 runningLock->Lock(); 1386 usleep(SLEEP_AFTER_LOCK_TIME_US); 1387 bool result = false; 1388 PowerErrors error = powerMgrClient.IsRunningLockEnabled(RunningLockType::RUNNINGLOCK_SCREEN, result); 1389 POWER_HILOGD(LABEL_TEST, "IsRunningLockEnabled error %{public}d", static_cast<int32_t>(error)); 1390 EXPECT_TRUE(result) << "PowerMgrClient056: IsRunningLockEnabled Fail, result is false" ; 1391 runningLock->UnLock(); 1392 POWER_HILOGD(LABEL_TEST, "PowerMgrClient056::fun is end!"); 1393 } 1394 } // namespace