1 /* 2 * Copyright (c) 2025 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 <gtest/gtest.h> 17 18 #include "error_multimodal.h" 19 #include "key_monitor_manager.h" 20 #include "mmi_log.h" 21 #include "input_windows_manager.h" 22 23 #undef MMI_LOG_DOMAIN 24 #define MMI_LOG_DOMAIN MMI_LOG_HANDLER 25 #undef MMI_LOG_TAG 26 #define MMI_LOG_TAG "KeyMonitorManagerTest" 27 28 namespace OHOS { 29 namespace MMI { 30 using namespace testing; 31 using namespace testing::ext; 32 33 class KeyMonitorManagerTest : public testing::Test { 34 public: SetUpTestCase(void)35 static void SetUpTestCase(void) 36 {} TearDownTestCase(void)37 static void TearDownTestCase(void) 38 {} 39 }; 40 41 /** 42 * @tc.name: KeyMonitorManagerTest_Monitor_LessThanOperator_01 43 * @tc.desc: Verify the correctness of the less-than operator in Monitor 44 * @tc.type: FUNC 45 * @tc.require: 46 */ 47 HWTEST_F(KeyMonitorManagerTest, KeyMonitorManagerTest_Monitor_LessThanOperator_01, TestSize.Level1) 48 { 49 CALL_TEST_DEBUG; 50 KeyMonitorManager::Monitor monitor1{ 51 .session_ = 1, .key_ = KeyEvent::KEYCODE_A, .action_ = KeyEvent::KEY_ACTION_UNKNOWN, .isRepeat_ = false}; 52 KeyMonitorManager::Monitor monitor2{ 53 .session_ = 2, .key_ = KeyEvent::KEYCODE_A, .action_ = KeyEvent::KEY_ACTION_UNKNOWN, .isRepeat_ = false}; 54 EXPECT_TRUE(monitor1 < monitor2); 55 56 KeyMonitorManager::Monitor monitor3{ 57 .session_ = 1, .key_ = KeyEvent::KEYCODE_A, .action_ = KeyEvent::KEY_ACTION_UNKNOWN, .isRepeat_ = false}; 58 KeyMonitorManager::Monitor monitor4{ 59 .session_ = 1, .key_ = KeyEvent::KEYCODE_B, .action_ = KeyEvent::KEY_ACTION_UNKNOWN, .isRepeat_ = false}; 60 EXPECT_TRUE(monitor3 < monitor4); 61 62 KeyMonitorManager::Monitor monitor5{ 63 .session_ = 1, .key_ = KeyEvent::KEYCODE_A, .action_ = KeyEvent::KEY_ACTION_UNKNOWN, .isRepeat_ = true}; 64 KeyMonitorManager::Monitor monitor6{ 65 .session_ = 1, .key_ = KeyEvent::KEYCODE_A, .action_ = KeyEvent::KEY_ACTION_CANCEL, .isRepeat_ = true}; 66 EXPECT_TRUE(monitor5 < monitor6); 67 68 KeyMonitorManager::Monitor monitor7{ 69 .session_ = 1, .key_ = KeyEvent::KEYCODE_A, .action_ = KeyEvent::KEY_ACTION_UNKNOWN, .isRepeat_ = true}; 70 KeyMonitorManager::Monitor monitor8{ 71 .session_ = 1, .key_ = KeyEvent::KEYCODE_A, .action_ = KeyEvent::KEY_ACTION_UNKNOWN, .isRepeat_ = true}; 72 EXPECT_FALSE(monitor7 < monitor8); 73 } 74 75 /** 76 * @tc.name: KeyMonitorManagerTest_AddMonitor_01 77 * @tc.desc: Verify the AddMonitor 78 * @tc.type: FUNC 79 * @tc.require: 80 */ 81 HWTEST_F(KeyMonitorManagerTest, KeyMonitorManagerTest_AddMonitor_01, TestSize.Level1) 82 { 83 CALL_TEST_DEBUG; 84 std::shared_ptr<KeyMonitorManager> keyMonitorManager = std::make_shared<KeyMonitorManager>(); 85 KeyMonitorManager::Monitor monitor1{ 86 .session_ = 1, .key_ = KeyEvent::KEYCODE_VOLUME_UP, .action_ = KeyEvent::KEY_ACTION_UP, .isRepeat_ = true}; 87 int32_t ret = keyMonitorManager->AddMonitor(monitor1); 88 EXPECT_EQ(ret, -PARAM_INPUT_INVALID); 89 90 KeyMonitorManager::Monitor monitor2{ 91 .session_ = 1, .key_ = KeyEvent::KEYCODE_VOLUME_UP, .action_ = KeyEvent::KEY_ACTION_DOWN, .isRepeat_ = true}; 92 ret = keyMonitorManager->AddMonitor(monitor2); 93 EXPECT_EQ(ret, RET_OK); 94 95 ret = keyMonitorManager->AddMonitor(monitor2); 96 EXPECT_EQ(ret, RET_OK); 97 } 98 99 /** 100 * @tc.name: KeyMonitorManagerTest_RemoveMonitor_01 101 * @tc.desc: Verify the RemoveMonitor 102 * @tc.type: FUNC 103 * @tc.require: 104 */ 105 HWTEST_F(KeyMonitorManagerTest, KeyMonitorManagerTest_RemoveMonitor_01, TestSize.Level1) 106 { 107 CALL_TEST_DEBUG; 108 std::shared_ptr<KeyMonitorManager> keyMonitorManager = std::make_shared<KeyMonitorManager>(); 109 size_t size = keyMonitorManager->monitors_.size(); 110 111 KeyMonitorManager::Monitor monitor1{ 112 .session_ = 1, .key_ = KeyEvent::KEYCODE_VOLUME_UP, .action_ = KeyEvent::KEY_ACTION_DOWN, .isRepeat_ = true}; 113 int32_t ret = keyMonitorManager->AddMonitor(monitor1); 114 EXPECT_EQ(ret, RET_OK); 115 116 EXPECT_GT(keyMonitorManager->monitors_.size(), size); 117 keyMonitorManager->RemoveMonitor(monitor1); 118 119 EXPECT_EQ(keyMonitorManager->monitors_.size(), size); 120 121 keyMonitorManager->RemoveMonitor(monitor1); 122 EXPECT_EQ(keyMonitorManager->monitors_.size(), size); 123 } 124 /** 125 * @tc.name: KeyMonitorManagerTest_Intercept_01 126 * @tc.desc: Verify the Intercept function 127 * @tc.type: FUNC 128 * @tc.require: 129 */ 130 HWTEST_F(KeyMonitorManagerTest, KeyMonitorManagerTest_Intercept_01, TestSize.Level1) 131 { 132 CALL_TEST_DEBUG; 133 std::shared_ptr<KeyMonitorManager> keyMonitorManager = std::make_shared<KeyMonitorManager>(); 134 KeyMonitorManager::Monitor monitor1{ 135 .session_ = 0, .key_ = KeyEvent::KEYCODE_VOLUME_UP, .action_ = KeyEvent::KEY_ACTION_DOWN, .isRepeat_ = true}; 136 keyMonitorManager->monitors_.emplace(monitor1); 137 EXPECT_EQ(keyMonitorManager->monitors_.size(), 1); 138 139 std::shared_ptr<KeyEvent> keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_VOLUME_UP); 140 keyEvent->SetKeyCode(monitor1.key_); 141 keyEvent->SetKeyAction(monitor1.action_); 142 EXPECT_FALSE(keyMonitorManager->Intercept(keyEvent)); 143 144 keyEvent->SetKeyCode(KeyEvent::KEYCODE_UNKNOWN); 145 EXPECT_FALSE(keyMonitorManager->Intercept(keyEvent)); 146 } 147 148 /** 149 * @tc.name: KeyMonitorManagerTest_Intercept_02 150 * @tc.desc: Verify the Intercept function 151 * @tc.type: FUNC 152 * @tc.require: 153 */ 154 HWTEST_F(KeyMonitorManagerTest, KeyMonitorManagerTest_Intercept_02, TestSize.Level1) 155 { 156 CALL_TEST_DEBUG; 157 std::shared_ptr<KeyMonitorManager> keyMonitorManager = std::make_shared<KeyMonitorManager>(); 158 std::shared_ptr<KeyEvent> keyEvent1 = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_VOLUME_UP); 159 KeyMonitorManager::Monitor monitor1{ 160 .session_ = 1, .key_ = KeyEvent::KEY_ACTION_DOWN, .action_ = KeyEvent::KEY_ACTION_DOWN, .isRepeat_ = true}; 161 keyMonitorManager->monitors_.emplace(monitor1); 162 EXPECT_EQ(keyMonitorManager->monitors_.size(), 1); 163 164 keyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_UP); 165 int32_t delay = 0; 166 EXPECT_FALSE(keyMonitorManager->Intercept(keyEvent1, delay)); 167 168 keyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 169 EXPECT_FALSE(keyMonitorManager->Intercept(keyEvent1, delay)); 170 171 delay = 1; 172 keyEvent1->SetKeyCode(monitor1.key_); 173 keyEvent1->SetKeyAction(monitor1.action_); 174 EXPECT_FALSE(keyMonitorManager->Intercept(keyEvent1, delay)); 175 176 keyEvent1->SetKeyCode(KeyEvent::KEY_ACTION_UP); 177 EXPECT_FALSE(keyMonitorManager->Intercept(keyEvent1, delay)); 178 } 179 180 /** 181 * @tc.name: KeyMonitorManagerTest_OnSessionLost_01 182 * @tc.desc: Verify the OnSessionLost function 183 * @tc.type: FUNC 184 * @tc.require: 185 */ 186 HWTEST_F(KeyMonitorManagerTest, KeyMonitorManagerTest_OnSessionLost_01, TestSize.Level1) 187 { 188 CALL_TEST_DEBUG; 189 std::shared_ptr<KeyMonitorManager> keyMonitorManager = std::make_shared<KeyMonitorManager>(); 190 KeyMonitorManager::Monitor monitor1{ 191 .session_ = 1, .key_ = KeyEvent::KEY_ACTION_DOWN, .action_ = KeyEvent::KEY_ACTION_DOWN, .isRepeat_ = true}; 192 int32_t session = monitor1.session_ + 1; 193 keyMonitorManager->monitors_.emplace(monitor1); 194 EXPECT_EQ(keyMonitorManager->monitors_.size(), 1); 195 keyMonitorManager->OnSessionLost(session); 196 EXPECT_EQ(keyMonitorManager->monitors_.size(), 1); 197 session = monitor1.session_; 198 keyMonitorManager->OnSessionLost(session); 199 EXPECT_EQ(keyMonitorManager->monitors_.size(), 0); 200 } 201 } // namespace MMI 202 } // namespace OHOS 203