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 <cstdio>
17 #include <gtest/gtest.h>
18
19 #include "define_multimodal.h"
20 #include "input_device_consumer_handler.h"
21 #include "input_event_handler.h"
22
23 #include "mock.h"
24
25
26 #undef MMI_LOG_TAG
27 #define MMI_LOG_TAG "InputDeviceConsumerHandlerTest"
28
29 namespace OHOS {
30 namespace MMI {
31 using namespace testing;
32 using namespace testing::ext;
33
34 const std::string PROGRAM_NAME { "uds_session_test" };
35 constexpr int32_t MODULE_TYPE { 1 };
36 constexpr int32_t UDS_FD { 1 };
37 constexpr int32_t UDS_UID { 100 };
38 constexpr int32_t UDS_PID { 100 };
39
40 class InputDeviceConsumerHandlerTest : public testing::Test {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44 void SetUp();
45 void TearDown();
46 };
47
SetUpTestCase(void)48 void InputDeviceConsumerHandlerTest::SetUpTestCase(void)
49 {
50 }
51
TearDownTestCase(void)52 void InputDeviceConsumerHandlerTest::TearDownTestCase(void)
53 {
54 }
55
SetUp()56 void InputDeviceConsumerHandlerTest::SetUp()
57 {
58 }
59
TearDown()60 void InputDeviceConsumerHandlerTest::TearDown()
61 {
62 MOCKHANDLER->DestroyInstance();
63 DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_.clear();
64 }
65
66 /**
67 * @tc.name: InputDeviceConsumerHandlerTest_SetDeviceConsumerHandler
68 * @tc.desc: Test SetDeviceConsumerHandler
69 * @tc.type: FUNC
70 * @tc.require:
71 */
72 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_SetDeviceConsumerHandler, TestSize.Level1)
73 {
74 std::vector<std::string> deviceNames;
75 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
76 std::string name = "test";
77 deviceNames.push_back("ttttt");
78 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID);
79 auto ret = DEVICEHANDLER->SetDeviceConsumerHandler(deviceNames, sess);
80 DEVICEHANDLER->HandleDeviceConsumerEvent(name, pointerEvent);
81 ASSERT_EQ(ret, RET_ERR);
82 }
83
84 /**
85 * @tc.name: InputDeviceConsumerHandlerTest_ClearDeviceConsumerHandler
86 * @tc.desc: Test SetDeviceConsumerHandler
87 * @tc.type: FUNC
88 * @tc.require:
89 */
90 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_ClearDeviceConsumerHandler, TestSize.Level1)
91 {
92 std::vector<std::string> deviceNames;
93 deviceNames.push_back("test");
94 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID);
95 auto ret = DEVICEHANDLER->ClearDeviceConsumerHandler(deviceNames, sess);
96 ASSERT_EQ(ret, RET_OK);
97 }
98
99 /**
100 * @tc.name: InputDeviceConsumerHandlerTest_RemoveDeviceHandler
101 * @tc.desc: Test SetDeviceConsumerHandler
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_RemoveDeviceHandler, TestSize.Level1)
106 {
107 std::vector<std::string> deviceNames;
108 deviceNames.push_back("test");
109 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID);
110 auto ret = DEVICEHANDLER->deviceConsumerHandler_.RemoveDeviceHandler(deviceNames, sess);
111 ASSERT_EQ(ret, RET_OK);
112 }
113
114 /**
115 * @tc.name: InputDeviceConsumerHandlerTest_SetDeviceConsumerHandler_001
116 * @tc.desc: Test SetDeviceConsumerHandler
117 * @tc.type: FUNC
118 * @tc.require:
119 */
120 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_SetDeviceConsumerHandler_001, TestSize.Level1)
121 {
122 CALL_TEST_DEBUG;
123 std::vector<std::string> deviceNames = {"device1", "device2"};
124 SessionPtr session = nullptr;
125 auto ret = DEVICEHANDLER->SetDeviceConsumerHandler(deviceNames, session);
126 ASSERT_EQ(ret, ERROR_NULL_POINTER);
127 }
128
129 /**
130 * @tc.name: InputDeviceConsumerHandlerTest_SetDeviceConsumerHandler_002
131 * @tc.desc: Test SetDeviceConsumerHandler
132 * @tc.type: FUNC
133 * @tc.require:
134 */
135 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_SetDeviceConsumerHandler_002, TestSize.Level1)
136 {
137 CALL_TEST_DEBUG;
138 std::vector<std::string> deviceNames = {"device1", "device2"};
139 int32_t fd_1 = 1;
140 int32_t fd_2 = 2;
141 SessionPtr session1 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_1, UDS_UID, UDS_PID);
142 SessionPtr session2 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_2, UDS_UID, UDS_PID);
143 auto& deviceHandler = DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_;
144 auto sessionHandler = std::set<InputDeviceConsumerHandler::SessionHandler>{session1};
145 deviceHandler["device1"] = sessionHandler;
146 EXPECT_EQ(deviceHandler["device1"].size(), 1);
147 InputHandler->udsServer_ = nullptr;
148 auto ret = DEVICEHANDLER->SetDeviceConsumerHandler(deviceNames, session2);
149 EXPECT_EQ(deviceHandler.size(), 2);
150 EXPECT_EQ(deviceHandler["device1"].size(), 2);
151 ASSERT_EQ(ret, RET_ERR);
152 }
153
154 /**
155 * @tc.name: InputDeviceConsumerHandlerTest_SetDeviceConsumerHandler_003
156 * @tc.desc: Test SetDeviceConsumerHandler
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_SetDeviceConsumerHandler_003, TestSize.Level1)
161 {
162 CALL_TEST_DEBUG;
163 std::vector<std::string> deviceNames = {"device1", "device2"};
164 int32_t fd_1 = 1;
165 int32_t fd_2 = 2;
166 SessionPtr session1 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_1, UDS_UID, UDS_PID);
167 SessionPtr session2 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_2, UDS_UID, UDS_PID);
168 auto& deviceHandler = DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_;
169 auto sessionHandler = std::set<InputDeviceConsumerHandler::SessionHandler>{session1};
170 deviceHandler["device1"] = sessionHandler;
171 EXPECT_EQ(deviceHandler["device1"].size(), 1);
172 auto udsServer = std::make_shared<UDSServer>();
173 InputHandler->udsServer_ = udsServer.get();
174 MOCKHANDLER->mockSessionPara = session1;
175 auto ret = DEVICEHANDLER->SetDeviceConsumerHandler(deviceNames, session2);
176 EXPECT_EQ(deviceHandler.size(), 2);
177 EXPECT_EQ(deviceHandler["device1"].size(), 1);
178 ASSERT_EQ(ret, RET_OK);
179 }
180
181 /**
182 * @tc.name: InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_001
183 * @tc.desc: Test HandleDeviceConsumerEvent
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_001, TestSize.Level1)
188 {
189 CALL_TEST_DEBUG;
190 std::string name = "device1";
191 std::shared_ptr<PointerEvent> pointerEvent = nullptr;
192 ASSERT_NO_FATAL_FAILURE(DEVICEHANDLER->HandleDeviceConsumerEvent(name, pointerEvent));
193 }
194
195 /**
196 * @tc.name: InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_002
197 * @tc.desc: Test HandleDeviceConsumerEvent
198 * @tc.type: FUNC
199 * @tc.require:
200 */
201 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_002, TestSize.Level1)
202 {
203 CALL_TEST_DEBUG;
204 std::string name = "device1";
205 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
206 ASSERT_NO_FATAL_FAILURE(DEVICEHANDLER->HandleDeviceConsumerEvent(name, pointerEvent));
207 }
208
209 /**
210 * @tc.name: InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_003
211 * @tc.desc: Test HandleDeviceConsumerEvent
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_003, TestSize.Level1)
216 {
217 CALL_TEST_DEBUG;
218 std::string name = "device1";
219 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
220 auto& deviceHandler = DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_;
221 auto sessionHandler = std::set<InputDeviceConsumerHandler::SessionHandler>();
222 deviceHandler["device1"] = sessionHandler;
223 MOCKHANDLER->mockChkRWErrorRet = true;
224 ASSERT_NO_FATAL_FAILURE(DEVICEHANDLER->HandleDeviceConsumerEvent(name, pointerEvent));
225 }
226
227 /**
228 * @tc.name: InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_004
229 * @tc.desc: Test HandleDeviceConsumerEvent
230 * @tc.type: FUNC
231 * @tc.require:
232 */
233 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_004, TestSize.Level1)
234 {
235 CALL_TEST_DEBUG;
236 std::string name = "device1";
237 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
238 auto& deviceHandler = DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_;
239 auto sessionHandler = std::set<InputDeviceConsumerHandler::SessionHandler>();
240 deviceHandler["device1"] = sessionHandler;
241 MOCKHANDLER->mockChkRWErrorRet = false;
242 PointerEvent::PointerItem item;
243 item.SetPointerId(0);
244 item.SetOrientation(0);
245 item.SetBlobId(0);
246 item.SetToolType(0);
247 pointerEvent->UpdatePointerItem(0, item);
248 MOCKHANDLER->mockGetPointerItemRet = false;
249 ASSERT_NO_FATAL_FAILURE(DEVICEHANDLER->HandleDeviceConsumerEvent(name, pointerEvent));
250 }
251
252 /**
253 * @tc.name: InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_005
254 * @tc.desc: Test HandleDeviceConsumerEvent
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_005, TestSize.Level1)
259 {
260 CALL_TEST_DEBUG;
261 std::string name = "device1";
262 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
263 auto& deviceHandler = DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_;
264 auto sessionHandler = std::set<InputDeviceConsumerHandler::SessionHandler>();
265 deviceHandler["device1"] = sessionHandler;
266 MOCKHANDLER->mockChkRWErrorRet = false;
267 PointerEvent::PointerItem item;
268 item.SetPointerId(0);
269 item.SetOrientation(0);
270 item.SetBlobId(0);
271 item.SetToolType(0);
272 pointerEvent->UpdatePointerItem(0, item);
273 MOCKHANDLER->mockGetPointerItemRet = true;
274 MOCKHANDLER->mockMarshallingRet = RET_ERR;
275 ASSERT_NO_FATAL_FAILURE(DEVICEHANDLER->HandleDeviceConsumerEvent(name, pointerEvent));
276 }
277
278 /**
279 * @tc.name: InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_006
280 * @tc.desc: Test HandleDeviceConsumerEvent
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_006, TestSize.Level1)
285 {
286 CALL_TEST_DEBUG;
287 std::string name = "device1";
288 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
289 MOCKHANDLER->mockChkRWErrorRet = false;
290 PointerEvent::PointerItem item;
291 item.SetPointerId(0);
292 item.SetOrientation(0);
293 item.SetBlobId(0);
294 item.SetToolType(0);
295 pointerEvent->UpdatePointerItem(0, item);
296 MOCKHANDLER->mockGetPointerItemRet = true;
297 MOCKHANDLER->mockMarshallingRet = RET_OK;
298 int32_t fd_1 = 1;
299 int32_t fd_2 = 2;
300 SessionPtr session1 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_1, UDS_UID, UDS_PID);
301 SessionPtr session2 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_2, UDS_UID, UDS_PID);
302 auto& deviceHandler = DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_;
303 auto sessionHandler1 = std::set<InputDeviceConsumerHandler::SessionHandler>{session1};
304 auto sessionHandler2 = std::set<InputDeviceConsumerHandler::SessionHandler>{session2};
305 deviceHandler["device1"] = sessionHandler1;
306 deviceHandler["device2"] = sessionHandler2;
307 MOCKHANDLER->mockSendMsgRet = false;
308 ASSERT_NO_FATAL_FAILURE(DEVICEHANDLER->HandleDeviceConsumerEvent(name, pointerEvent));
309 }
310
311 /**
312 * @tc.name: InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_007
313 * @tc.desc: Test HandleDeviceConsumerEvent
314 * @tc.type: FUNC
315 * @tc.require:
316 */
317 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_HandleDeviceConsumerEvent_007, TestSize.Level1)
318 {
319 CALL_TEST_DEBUG;
320 std::string name = "device1";
321 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
322 MOCKHANDLER->mockChkRWErrorRet = false;
323 PointerEvent::PointerItem item;
324 item.SetPointerId(0);
325 item.SetOrientation(0);
326 item.SetBlobId(0);
327 item.SetToolType(0);
328 pointerEvent->UpdatePointerItem(0, item);
329 MOCKHANDLER->mockGetPointerItemRet = true;
330 MOCKHANDLER->mockMarshallingRet = RET_OK;
331 int32_t fd_1 = 1;
332 int32_t fd_2 = 2;
333 SessionPtr session1 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_1, UDS_UID, UDS_PID);
334 SessionPtr session2 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_2, UDS_UID, UDS_PID);
335 auto& deviceHandler = DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_;
336 auto sessionHandler1 = std::set<InputDeviceConsumerHandler::SessionHandler>{session1};
337 auto sessionHandler2 = std::set<InputDeviceConsumerHandler::SessionHandler>{session2};
338 deviceHandler["device1"] = sessionHandler1;
339 deviceHandler["device2"] = sessionHandler2;
340 MOCKHANDLER->mockSendMsgRet = true;
341 ASSERT_NO_FATAL_FAILURE(DEVICEHANDLER->HandleDeviceConsumerEvent(name, pointerEvent));
342 }
343
344 /**
345 * @tc.name: InputDeviceConsumerHandlerTest_RemoveDeviceHandler
346 * @tc.desc: Test SetDeviceConsumerHandler
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(InputDeviceConsumerHandlerTest, InputDeviceConsumerHandlerTest_RemoveDeviceHandler_001, TestSize.Level1)
351 {
352 CALL_TEST_DEBUG;
353 std::vector<std::string> deviceNames = {"device1", "device2"};
354 int32_t fd_1 = 1;
355 int32_t fd_2 = 2;
356 SessionPtr session1 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_1, UDS_UID, UDS_PID);
357 SessionPtr session2 = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, fd_2, UDS_UID, UDS_PID);
358 auto& deviceHandler = DEVICEHANDLER->deviceConsumerHandler_.deviceHandler_;
359 auto sessionHandler = std::set<InputDeviceConsumerHandler::SessionHandler>{session1, session2};
360 deviceHandler["device1"] = sessionHandler;
361 EXPECT_EQ(deviceHandler["device1"].size(), 2);
362 auto ret = DEVICEHANDLER->deviceConsumerHandler_.RemoveDeviceHandler(deviceNames, session2);
363 ASSERT_EQ(ret, RET_OK);
364 EXPECT_EQ(deviceHandler["device1"].size(), 1);
365 }
366 } // namespace MMI
367 } // namespace OHOS