1 /* 2 * Copyright (c) 2023-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 #include "power_suspend_test.h" 16 #include <fstream> 17 #include <thread> 18 #include <unistd.h> 19 20 #ifdef POWERMGR_GTEST 21 #define private public 22 #define protected public 23 #endif 24 25 #include <datetime_ex.h> 26 #ifdef HAS_MULTIMODALINPUT_INPUT_PART 27 #include <input_manager.h> 28 #endif 29 #include <securec.h> 30 31 #include "power_mgr_client.h" 32 #include "power_state_callback_stub.h" 33 #include "power_state_machine.h" 34 #include "setting_helper.h" 35 36 using namespace testing::ext; 37 using namespace OHOS::PowerMgr; 38 using namespace OHOS; 39 using namespace std; 40 static constexpr int32_t SLEEP_WAIT_TIME_S = 2; 41 static constexpr int32_t SCREEN_OFF_TIME_MS = 5000; 42 static constexpr int32_t NEXT_WAIT_TIME_S = 1; 43 44 namespace { 45 /** 46 * @tc.name: PowerSuspendTest001 47 * @tc.desc: test simulate powerkey event when screenon 48 * @tc.type: FUNC 49 */ 50 #ifdef HAS_MULTIMODALINPUT_INPUT_PART 51 HWTEST_F(PowerSuspendTest, PowerSuspendTest001, TestSize.Level1) 52 { 53 POWER_HILOGI(LABEL_TEST, "PowerSuspendTest001 function start!"); 54 auto& powerMgrClient = PowerMgrClient::GetInstance(); 55 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, "PowerSuspendTest001"); 56 EXPECT_TRUE(powerMgrClient.IsScreenOn()); 57 58 std::shared_ptr<MMI::KeyEvent> keyEventPowerkeyDown = MMI::KeyEvent::Create(); 59 keyEventPowerkeyDown->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN); 60 keyEventPowerkeyDown->SetKeyCode(MMI::KeyEvent::KEYCODE_POWER); 61 std::shared_ptr<MMI::KeyEvent> keyEventPowerkeyUp = MMI::KeyEvent::Create(); 62 keyEventPowerkeyUp->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP); 63 keyEventPowerkeyUp->SetKeyCode(MMI::KeyEvent::KEYCODE_POWER); 64 65 auto inputManager = MMI::InputManager::GetInstance(); 66 inputManager->SimulateInputEvent(keyEventPowerkeyDown); 67 inputManager->SimulateInputEvent(keyEventPowerkeyUp); 68 sleep(4); 69 EXPECT_FALSE(powerMgrClient.IsScreenOn()); 70 POWER_HILOGI(LABEL_TEST, "PowerSuspendTest001 function end!"); 71 } 72 #endif 73 74 /** 75 * @tc.name: PowerSuspendTest002 76 * @tc.desc: test simulate powerkey event once when screenon 77 * @tc.type: FUNC 78 */ 79 #ifdef HAS_MULTIMODALINPUT_INPUT_PART 80 HWTEST_F(PowerSuspendTest, PowerSuspendTest002, TestSize.Level1) 81 { 82 POWER_HILOGI(LABEL_TEST, "PowerSuspendTest002 function start!"); 83 auto& powerMgrClient = PowerMgrClient::GetInstance(); 84 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON, "PowerSuspendTest002"); 85 EXPECT_TRUE(powerMgrClient.IsScreenOn()); 86 87 auto inputManager = MMI::InputManager::GetInstance(); 88 std::shared_ptr<MMI::KeyEvent> keyEventPowerkeyDown = MMI::KeyEvent::Create(); 89 keyEventPowerkeyDown->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN); 90 keyEventPowerkeyDown->SetKeyCode(MMI::KeyEvent::KEYCODE_POWER); 91 std::shared_ptr<MMI::KeyEvent> keyEventPowerkeyUp = MMI::KeyEvent::Create(); 92 keyEventPowerkeyUp->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP); 93 keyEventPowerkeyUp->SetKeyCode(MMI::KeyEvent::KEYCODE_POWER); 94 95 inputManager->SimulateInputEvent(keyEventPowerkeyDown); 96 inputManager->SimulateInputEvent(keyEventPowerkeyUp); 97 inputManager->SimulateInputEvent(keyEventPowerkeyDown); 98 inputManager->SimulateInputEvent(keyEventPowerkeyUp); 99 powerMgrClient.OverrideScreenOffTime(SCREEN_OFF_TIME_MS); 100 sleep(3); 101 // the second powerkey event would interrupt the transition to INACTIVE 102 EXPECT_TRUE(powerMgrClient.IsScreenOn()); 103 104 POWER_HILOGI(LABEL_TEST, "PowerSuspendTest002 function end!"); 105 } 106 #endif 107 108 /** 109 * @tc.name: PowerSuspendTest003 110 * @tc.desc: test IsForceSleeping 111 * @tc.type: FUNC 112 * @tc.require: issueICE3O4 113 */ 114 HWTEST_F(PowerSuspendTest, PowerSuspendTest003, TestSize.Level2) 115 { 116 POWER_HILOGI(LABEL_TEST, "PowerSuspendTest003 function start!"); 117 auto& powerMgrClient = PowerMgrClient::GetInstance(); 118 int32_t wakeupReason = (static_cast<int32_t>(WakeupDeviceType::WAKEUP_DEVICE_MAX)) + 1; 119 WakeupDeviceType abnormaltype = WakeupDeviceType(wakeupReason); 120 powerMgrClient.WakeupDevice(); 121 sleep(NEXT_WAIT_TIME_S); 122 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false); 123 powerMgrClient.SuspendDevice(); 124 sleep(NEXT_WAIT_TIME_S); 125 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false); 126 127 powerMgrClient.WakeupDevice(); 128 sleep(NEXT_WAIT_TIME_S); 129 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false); 130 powerMgrClient.ForceSuspendDevice(); 131 sleep(NEXT_WAIT_TIME_S); 132 #ifdef POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST 133 EXPECT_EQ(powerMgrClient.IsForceSleeping(), true); 134 #else 135 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false); 136 #endif 137 powerMgrClient.WakeupDevice(abnormaltype); 138 sleep(NEXT_WAIT_TIME_S); 139 #ifdef POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST 140 EXPECT_EQ(powerMgrClient.IsForceSleeping(), true); 141 #else 142 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false); 143 #endif 144 powerMgrClient.WakeupDevice(); 145 sleep(NEXT_WAIT_TIME_S); 146 EXPECT_EQ(powerMgrClient.IsForceSleeping(), false); 147 POWER_HILOGI(LABEL_TEST, "PowerSuspendTest003 function end!"); 148 } 149 } // namespace 150