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