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 "input_scene_board_judgement.h" 19 #include "pre_monitor_manager.h" 20 #include "multimodal_event_handler.h" 21 #include "mmi_log.h" 22 23 #undef MMI_LOG_TAG 24 #define MMI_LOG_TAG "PreMonitorManagerTest" 25 26 namespace OHOS { 27 namespace MMI { 28 namespace { 29 using namespace testing::ext; 30 } // namespace 31 32 class PreMonitorManagerTest : public testing::Test { 33 public: SetUpTestCase(void)34 static void SetUpTestCase(void) {} TearDownTestCase(void)35 static void TearDownTestCase(void) {} 36 }; 37 38 /** 39 * @tc.name: PreMonitorManagerTest_FindHandler_001 40 * @tc.desc: Test FindHandler 41 * @tc.type: FUNC 42 * @tc.require: 43 */ 44 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_FindHandler_001, TestSize.Level1) 45 { 46 CALL_TEST_DEBUG; 47 PreMonitorManager manager; 48 int32_t handlerId = 1; 49 ASSERT_NO_FATAL_FAILURE(manager.FindHandler(handlerId)); 50 handlerId = -1; 51 ASSERT_NO_FATAL_FAILURE(manager.FindHandler(handlerId)); 52 } 53 54 /** 55 * @tc.name: PreMonitorManagerTest_FindHandler_002 56 * @tc.desc: Test FindHandler 57 * @tc.type: FUNC 58 * @tc.require: 59 */ 60 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_FindHandler_002, TestSize.Level1) 61 { 62 CALL_TEST_DEBUG; 63 PreMonitorManager manager; 64 int32_t handlerId = 1; 65 PreMonitorManager::Handler handler; 66 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 67 handler.callback_ = consumer; 68 manager.monitorHandlers_[handlerId] = handler; 69 std::shared_ptr<IInputEventConsumer> result = manager.FindHandler(handlerId); 70 ASSERT_EQ(result, consumer); 71 } 72 73 /** 74 * @tc.name: PreMonitorManagerTest_AddHandler_001 75 * @tc.desc: Test AddHandler 76 * @tc.type: FUNC 77 * @tc.require: 78 */ 79 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_AddHandler_001, TestSize.Level1) 80 { 81 CALL_TEST_DEBUG; 82 PreMonitorManager manager; 83 HandleEventType eventType = HANDLE_EVENT_TYPE_PRE_KEY; 84 std::vector<int32_t> keys = {1, 2, 3}; 85 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 86 int32_t ret = manager.AddHandler(consumer, eventType, keys); 87 EXPECT_EQ(ret, RET_ERR); 88 } 89 90 /** 91 * @tc.name: PreMonitorManagerTest_RemoveHandler_001 92 * @tc.desc: Test RemoveHandler 93 * @tc.type: FUNC 94 * @tc.require: 95 */ 96 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_RemoveHandler_001, TestSize.Level1) 97 { 98 CALL_TEST_DEBUG; 99 PreMonitorManager manager; 100 int32_t handlerId = 1; 101 PreMonitorManager::Handler handler; 102 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 103 handler.callback_ = consumer; 104 manager.monitorHandlers_[handlerId] = handler; 105 int32_t ret = manager.RemoveHandler(0); 106 EXPECT_EQ(ret, RET_ERR); 107 ASSERT_NO_FATAL_FAILURE(manager.RemoveHandler(1)); 108 } 109 110 /** 111 * @tc.name: PreMonitorManagerTest_AddLocal_001 112 * @tc.desc: Test AddLocal 113 * @tc.type: FUNC 114 * @tc.require: 115 */ 116 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_AddLocal_001, TestSize.Level1) 117 { 118 CALL_TEST_DEBUG; 119 PreMonitorManager manager; 120 HandleEventType eventType = HANDLE_EVENT_TYPE_PRE_KEY; 121 int32_t handlerId = 1; 122 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 123 std::vector<int32_t> keys = {1, 2, 3}; 124 int32_t ret = manager.AddLocal(handlerId, eventType, keys, consumer); 125 EXPECT_EQ(ret, RET_OK); 126 ret = manager.AddLocal(handlerId, eventType, keys, consumer); 127 EXPECT_EQ(ret, RET_ERR); 128 } 129 130 /** 131 * @tc.name: PreMonitorManagerTest_RemoveLocal_001 132 * @tc.desc: Test RemoveLocal 133 * @tc.type: FUNC 134 * @tc.require: 135 */ 136 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_RemoveLocal_001, TestSize.Level1) 137 { 138 CALL_TEST_DEBUG; 139 PreMonitorManager manager; 140 HandleEventType eventType = HANDLE_EVENT_TYPE_PRE_KEY; 141 int32_t handlerId = 1; 142 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 143 std::vector<int32_t> keys = {1, 2, 3}; 144 int32_t ret = manager.AddLocal(handlerId, eventType, keys, consumer); 145 ret = manager.RemoveLocal(handlerId); 146 EXPECT_EQ(ret, RET_OK); 147 ret = manager.RemoveLocal(handlerId); 148 EXPECT_EQ(ret, RET_ERR); 149 } 150 151 /** 152 * @tc.name: PreMonitorManagerTest_AddToServer_001 153 * @tc.desc: Test AddToServer 154 * @tc.type: FUNC 155 * @tc.require: 156 */ 157 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_AddToServer_001, TestSize.Level1) 158 { 159 CALL_TEST_DEBUG; 160 PreMonitorManager manager; 161 HandleEventType eventType = HANDLE_EVENT_TYPE_PRE_KEY; 162 int32_t handlerId = 1; 163 std::vector<int32_t> keys = {1, 2, 3}; 164 ASSERT_NO_FATAL_FAILURE(manager.AddToServer(handlerId, eventType, keys)); 165 } 166 167 /** 168 * @tc.name: PreMonitorManagerTest_RemoveFromServer_001 169 * @tc.desc: Test RemoveFromServer 170 * @tc.type: FUNC 171 * @tc.require: 172 */ 173 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_RemoveFromServer_001, TestSize.Level1) 174 { 175 CALL_TEST_DEBUG; 176 PreMonitorManager manager; 177 int32_t handlerId = 1; 178 ASSERT_NO_FATAL_FAILURE(manager.RemoveFromServer(handlerId)); 179 } 180 181 /** 182 * @tc.name: PreMonitorManagerTest_OnPreKeyEvent_001 183 * @tc.desc: Test OnPreKeyEvent 184 * @tc.type: FUNC 185 * @tc.require: 186 */ 187 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_OnPreKeyEvent_001, TestSize.Level1) 188 { 189 CALL_TEST_DEBUG; 190 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 191 ASSERT_NE(keyEvent, nullptr); 192 int32_t handlerId = 1; 193 ASSERT_NO_FATAL_FAILURE(PRE_MONITOR_MGR.OnPreKeyEvent(keyEvent, handlerId)); 194 } 195 196 /** 197 * @tc.name: PreMonitorManagerTest_GetNextId_001 198 * @tc.desc: Test GetNextId 199 * @tc.type: FUNC 200 * @tc.require: 201 */ 202 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_GetNextId_001, TestSize.Level1) 203 { 204 CALL_TEST_DEBUG; 205 PreMonitorManager manager; 206 manager.nextId_ = std::numeric_limits<int32_t>::max(); 207 int32_t result = manager.GetNextId(); 208 ASSERT_EQ(result, INVALID_HANDLER_ID); 209 } 210 211 /** 212 * @tc.name: PreMonitorManagerTest_GetNextId_002 213 * @tc.desc: Test GetNextId 214 * @tc.type: FUNC 215 * @tc.require: 216 */ 217 HWTEST_F(PreMonitorManagerTest, PreMonitorManagerTest_GetNextId_002, TestSize.Level1) 218 { 219 CALL_TEST_DEBUG; 220 PreMonitorManager manager; 221 manager.nextId_ = 5; 222 int32_t result = manager.GetNextId(); 223 ASSERT_EQ(result, 5); 224 } 225 } // namespace MMI 226 } // namespace OHOS 227