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