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 17 #include <gtest/gtest.h> 18 19 #include "input_device_impl.h" 20 #include "i_input_device_listener.h" 21 #include <cinttypes> 22 #include "bytrace_adapter.h" 23 #include "define_multimodal.h" 24 #include "error_multimodal.h" 25 #include "multimodal_event_handler.h" 26 27 #undef MMI_LOG_TAG 28 #define MMI_LOG_TAG "InputDeviceImplTest" 29 30 namespace OHOS { 31 namespace MMI { 32 namespace { 33 std::string INPUT_DEV_CHANGE_ADD_DEV = "add"; 34 std::string INPUT_DEV_CHANGE_REMOVE_DEV = "remove"; 35 using namespace testing::ext; 36 } // namespace 37 38 class InputDeviceImplTest : public testing::Test { 39 public: SetUpTestCase(void)40 static void SetUpTestCase(void) {} TearDownTestCase(void)41 static void TearDownTestCase(void) {} 42 }; 43 44 class InputDeviceListenerMock : public IInputDeviceListener { 45 public: 46 InputDeviceListenerMock() = default; 47 virtual ~InputDeviceListenerMock() = default; 48 OnDeviceAdded(int32_t deviceId,const std::string & type)49 void OnDeviceAdded(int32_t deviceId, const std::string &type) 50 { 51 MMI_HILOGI("OnDeviceAdded enter"); 52 return; 53 } 54 OnDeviceRemoved(int32_t deviceId,const std::string & type)55 void OnDeviceRemoved(int32_t deviceId, const std::string &type) 56 { 57 MMI_HILOGI("OnDeviceRemoved enter"); 58 return; 59 } 60 }; 61 62 /** 63 * @tc.name: InputDeviceImplTest_RegisterDevListener_001 64 * @tc.desc: Test RegisterDevListener 65 * @tc.type: FUNC 66 * @tc.require: 67 */ 68 HWTEST_F(InputDeviceImplTest, InputDeviceImplTest_RegisterDevListener_001, TestSize.Level1) 69 { 70 CALL_TEST_DEBUG; 71 InputDeviceImpl manager; 72 std::string type = "test"; 73 auto listener = std::make_shared<InputDeviceListenerMock>(); 74 int32_t ret = manager.RegisterDevListener(type, listener); 75 EXPECT_EQ(ret, RET_ERR); 76 77 std::list<InputDeviceImpl::InputDevListenerPtr> devListener; 78 devListener.push_back(listener); 79 manager.devListener_.insert(std::make_pair(CHANGED_TYPE, devListener)); 80 auto listener2 = std::make_shared<InputDeviceListenerMock>(); 81 ret = manager.RegisterDevListener(type, listener2); 82 EXPECT_EQ(ret, RET_ERR); 83 } 84 85 /** 86 * @tc.name: InputDeviceImplTest_OnDevListener_001 87 * @tc.desc: Test OnDevListener 88 * @tc.type: FUNC 89 * @tc.require: 90 */ 91 HWTEST_F(InputDeviceImplTest, InputDeviceImplTest_OnDevListener_001, TestSize.Level1) 92 { 93 CALL_TEST_DEBUG; 94 InputDeviceImpl manager; 95 manager.devListener_.clear(); 96 97 std::string type = INPUT_DEV_CHANGE_ADD_DEV; 98 int32_t deviceId = 0; 99 EXPECT_NO_FATAL_FAILURE(manager.OnDevListener(deviceId, type)); 100 101 auto listener = std::make_shared<InputDeviceListenerMock>(); 102 std::list<InputDeviceImpl::InputDevListenerPtr> devListener; 103 devListener.push_back(listener); 104 manager.devListener_.insert(std::make_pair(CHANGED_TYPE, devListener)); 105 EXPECT_NO_FATAL_FAILURE(manager.OnDevListener(deviceId, type)); 106 107 type = INPUT_DEV_CHANGE_REMOVE_DEV; 108 EXPECT_NO_FATAL_FAILURE(manager.OnDevListener(deviceId, type)); 109 110 type = "test"; 111 EXPECT_NO_FATAL_FAILURE(manager.OnDevListener(deviceId, type)); 112 } 113 114 /** 115 * @tc.name: InputDeviceImplTest_OnSetInputDeviceAck_001 116 * @tc.desc: Test OnSetInputDeviceAck 117 * @tc.type: FUNC 118 * @tc.require: 119 */ 120 HWTEST_F(InputDeviceImplTest, InputDeviceImplTest_OnSetInputDeviceAck_001, TestSize.Level1) 121 { 122 CALL_TEST_DEBUG; 123 InputDeviceImpl manager; 124 125 int32_t index = 0; 126 int32_t result = 0; 127 EXPECT_NO_FATAL_FAILURE(manager.OnSetInputDeviceAck(index, result)); 128 } 129 130 /** 131 * @tc.name: InputDeviceImplTest_OnConnected_001 132 * @tc.desc: Test OnConnected 133 * @tc.type: FUNC 134 * @tc.require: 135 */ 136 HWTEST_F(InputDeviceImplTest, InputDeviceImplTest_OnConnected_001, TestSize.Level1) 137 { 138 CALL_TEST_DEBUG; 139 InputDeviceImpl manager; 140 141 EXPECT_NO_FATAL_FAILURE(manager.OnConnected()); 142 143 manager.devListener_.clear(); 144 EXPECT_NO_FATAL_FAILURE(manager.OnConnected()); 145 146 auto listener = std::make_shared<InputDeviceListenerMock>(); 147 std::list<InputDeviceImpl::InputDevListenerPtr> devListener; 148 devListener.push_back(listener); 149 manager.devListener_.insert(std::make_pair(CHANGED_TYPE, devListener)); 150 EXPECT_NO_FATAL_FAILURE(manager.OnConnected()); 151 152 manager.isListeningProcess_ = true; 153 EXPECT_NO_FATAL_FAILURE(manager.OnConnected()); 154 } 155 156 /** 157 * @tc.name: InputDeviceImplTest_StopListeningToServer_001 158 * @tc.desc: Test StopListeningToServer 159 * @tc.type: FUNC 160 * @tc.require: 161 */ 162 HWTEST_F(InputDeviceImplTest, InputDeviceImplTest_StopListeningToServer_001, TestSize.Level1) 163 { 164 CALL_TEST_DEBUG; 165 InputDeviceImpl manager; 166 manager.isListeningProcess_ = true; 167 EXPECT_NO_FATAL_FAILURE(manager.StopListeningToServer()); 168 } 169 170 /** 171 * @tc.name: InputDeviceImplTest_SupportKeys_001 172 * @tc.desc: Test SupportKeys 173 * @tc.type: FUNC 174 * @tc.require: 175 */ 176 HWTEST_F(InputDeviceImplTest, InputDeviceImplTest_SupportKeys_001, TestSize.Level1) 177 { 178 CALL_TEST_DEBUG; 179 InputDeviceImpl manager; __anon597e11a50202(std::vector<bool> &event) 180 auto callback = [](std::vector<bool> &event) {}; 181 182 int32_t deviceId = 9999; 183 std::vector<int32_t> keyCodes; 184 EXPECT_EQ(manager.SupportKeys(deviceId, keyCodes, callback), RET_ERR); 185 } 186 } // namespace MMI 187 } // namespace OHOS 188