1 /*
2  * Copyright (c) 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 
16 #include <fstream>
17 
18 #include <gtest/gtest.h>
19 
20 #include "event_interceptor_handler.h"
21 #include "mmi_log.h"
22 #include "uds_server.h"
23 
24 namespace OHOS {
25 namespace MMI {
26 namespace {
27 using namespace testing::ext;
28 constexpr int32_t UID_ROOT { 0 };
29 const std::string PROGRAM_NAME = "uds_sesion_test";
30 int32_t g_moduleType = 3;
31 int32_t g_pid = 0;
32 int32_t g_writeFd = -1;
33 } // namespace
34 
35 class EventInterceptorHandlerTest : public testing::Test {
36 public:
SetUpTestCase(void)37     static void SetUpTestCase(void) {}
TearDownTestCase(void)38     static void TearDownTestCase(void) {}
39 };
40 
41 /**
42  * @tc.name: EventInterceptorHandler_Test_001
43  * @tc.desc: Test the function HandleKeyEvent
44  * @tc.type: FUNC
45  * @tc.require:
46  */
47 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_001, TestSize.Level1)
48 {
49     CALL_TEST_DEBUG;
50     EventInterceptorHandler handler;
51     std::shared_ptr<KeyEvent> event = KeyEvent::Create();
52     ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(event));
53 }
54 
55 /**
56  * @tc.name: EventInterceptorHandler_Test_002
57  * @tc.desc: Test the function HandlePointerEvent
58  * @tc.type: FUNC
59  * @tc.require:
60  */
61 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_002, TestSize.Level1)
62 {
63     CALL_TEST_DEBUG;
64     EventInterceptorHandler handler;
65     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
66     ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
67 }
68 
69 /**
70  * @tc.name: EventInterceptorHandler_Test_003
71  * @tc.desc: Test the function HandleTouchEvent
72  * @tc.type: FUNC
73  * @tc.require:
74  */
75 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_003, TestSize.Level1)
76 {
77     CALL_TEST_DEBUG;
78     EventInterceptorHandler handler;
79     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
80     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
81 }
82 
83 /**
84  * @tc.name: EventInterceptorHandler_Test_004
85  * @tc.desc: Test the function OnHandleEvent
86  * @tc.type: FUNC
87  * @tc.require:
88  */
89 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_004, TestSize.Level1)
90 {
91     CALL_TEST_DEBUG;
92     EventInterceptorHandler handler;
93     std::shared_ptr<KeyEvent> event = KeyEvent::Create();
94     EXPECT_FALSE(handler.OnHandleEvent(event));
95 }
96 
97 /**
98  * @tc.name: EventInterceptorHandler_Test_005
99  * @tc.desc: Test the function OnHandleEvent
100  * @tc.type: FUNC
101  * @tc.require:
102  */
103 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_005, TestSize.Level1)
104 {
105     CALL_TEST_DEBUG;
106     EventInterceptorHandler handler;
107     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
108     EXPECT_FALSE(handler.OnHandleEvent(pointerEvent));
109 }
110 
111 /**
112  * @tc.name: EventInterceptorHandler_Test_007
113  * @tc.desc: Test the function HandleEvent
114  * @tc.type: FUNC
115  * @tc.require:
116  */
117 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_007, TestSize.Level1)
118 {
119     CALL_TEST_DEBUG;
120     EventInterceptorHandler::InterceptorCollection interceptorHandler;
121     std::shared_ptr<KeyEvent> KeyEvent = KeyEvent::Create();
122     bool ret = interceptorHandler.HandleEvent(KeyEvent);
123     EXPECT_FALSE(ret);
124 }
125 
126 /**
127  * @tc.name: EventInterceptorHandler_Test_008
128  * @tc.desc: Test the function CheckInputDeviceSource
129  * @tc.type: FUNC
130  * @tc.require:
131  */
132 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_008, TestSize.Level1)
133 {
134     CALL_TEST_DEBUG;
135     EventInterceptorHandler::InterceptorCollection interceptorHandler;
136     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
137     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
138     uint32_t deviceTags = 4;
139     bool ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
140     EXPECT_TRUE(ret);
141 
142     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
143     deviceTags = 2;
144     ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
145     EXPECT_TRUE(ret);
146 
147     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
148     ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
149     EXPECT_TRUE(ret);
150 }
151 
152 /**
153  * @tc.name: EventInterceptorHandler_Test_009
154  * @tc.desc: Test the function HandleEvent
155  * @tc.type: FUNC
156  * @tc.require:
157  */
158 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_009, TestSize.Level1)
159 {
160     CALL_TEST_DEBUG;
161     EventInterceptorHandler::InterceptorCollection interceptorHandler;
162     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
163     bool ret = interceptorHandler.HandleEvent(pointerEvent);
164     EXPECT_FALSE(ret);
165 }
166 
167 /**
168  * @tc.name: EventInterceptorHandler_Test_010
169  * @tc.desc: Test the function HandleEvent
170  * @tc.type: FUNC
171  * @tc.require:
172  */
173 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_010, TestSize.Level1)
174 {
175     CALL_TEST_DEBUG;
176     EventInterceptorHandler::InterceptorCollection interceptorHandler;
177     InputHandlerType handlerType = InputHandlerType::NONE;
178     HandleEventType eventType = 0;
179     int32_t priority = 0;
180     uint32_t deviceTags = 0;
181     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
182         g_writeFd, UID_ROOT, g_pid);
183     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
184         deviceTags, sessionFirst);
185     interceptorHandler.interceptors_.push_back(interceptorFirst);
186     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
187     bool ret = interceptorHandler.HandleEvent(pointerEvent);
188     EXPECT_FALSE(ret);
189 }
190 
191 /**
192  * @tc.name: EventInterceptorHandler_AddInterceptor_01
193  * @tc.desc: Test AddInterceptor
194  * @tc.type: FUNC
195  * @tc.require:
196  */
197 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_01, TestSize.Level1)
198 {
199     CALL_TEST_DEBUG;
200     EventInterceptorHandler::InterceptorCollection interceptorHandler;
201     InputHandlerType handlerType = InputHandlerType::NONE;
202     HandleEventType eventType = 0;
203     int32_t priority = 0;
204     uint32_t deviceTags = 0;
205     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
206         g_writeFd, UID_ROOT, g_pid);
207     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
208         deviceTags, sessionFirst);
209 
210     handlerType = InputHandlerType::NONE;
211     eventType = 0;
212     priority = 0;
213     deviceTags = 0;
214     SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
215         g_writeFd, UID_ROOT, g_pid);
216     EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
217         deviceTags, sessionSecond);
218     for (int32_t i = 0; i < 20; i++) {
219         interceptorHandler.interceptors_.push_back(interceptorSecond);
220     }
221     ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
222 }
223 
224 /**
225  * @tc.name: EventInterceptorHandler_AddInterceptor_02
226  * @tc.desc: Test AddInterceptor
227  * @tc.type: FUNC
228  * @tc.require:
229  */
230 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_02, TestSize.Level1)
231 {
232     CALL_TEST_DEBUG;
233     EventInterceptorHandler::InterceptorCollection interceptorHandler;
234     InputHandlerType handlerType = InputHandlerType::NONE;
235     HandleEventType eventType = 0;
236     int32_t priority = 0;
237     uint32_t deviceTags = 0;
238     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
239         g_writeFd, UID_ROOT, g_pid);
240     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
241         deviceTags, sessionFirst);
242     for (int32_t i = 0; i < 20; i++) {
243         interceptorHandler.interceptors_.push_back(interceptorFirst);
244     }
245     ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
246 }
247 
248 /**
249  * @tc.name: EventInterceptorHandler_AddInterceptor_03
250  * @tc.desc: Test AddInterceptor
251  * @tc.type: FUNC
252  * @tc.require:
253  */
254 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_03, TestSize.Level1)
255 {
256     CALL_TEST_DEBUG;
257     EventInterceptorHandler::InterceptorCollection interceptorHandler;
258     InputHandlerType handlerType = InputHandlerType::NONE;
259     HandleEventType eventType = 0;
260     int32_t priority = 1;
261     uint32_t deviceTags = 0;
262     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
263         g_writeFd, UID_ROOT, g_pid);
264     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
265         deviceTags, sessionFirst);
266 
267     handlerType = InputHandlerType::NONE;
268     eventType = 0;
269     priority = 2;
270     deviceTags = 0;
271     SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
272         g_writeFd, UID_ROOT, g_pid);
273     EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
274         deviceTags, sessionSecond);
275     interceptorHandler.interceptors_.push_back(interceptorSecond);
276     ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
277 }
278 
279 /**
280  * @tc.name: EventInterceptorHandler_AddInterceptor_04
281  * @tc.desc: Test AddInterceptor
282  * @tc.type: FUNC
283  * @tc.require:
284  */
285 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_04, TestSize.Level1)
286 {
287     CALL_TEST_DEBUG;
288     EventInterceptorHandler::InterceptorCollection interceptorHandler;
289     InputHandlerType handlerType = InputHandlerType::NONE;
290     HandleEventType eventType = 0;
291     int32_t priority = 1;
292     uint32_t deviceTags = 0;
293     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
294         g_writeFd, UID_ROOT, g_pid);
295     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
296         deviceTags, sessionFirst);
297 
298     handlerType = InputHandlerType::NONE;
299     eventType = 0;
300     priority = 0;
301     deviceTags = 0;
302     SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
303         g_writeFd, UID_ROOT, g_pid);
304     EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
305         deviceTags, sessionSecond);
306     interceptorHandler.interceptors_.push_back(interceptorSecond);
307     ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
308 }
309 
310 /**
311  * @tc.name: EventInterceptorHandler_RemoveInterceptor_01
312  * @tc.desc: Test RemoveInterceptor
313  * @tc.type: FUNC
314  * @tc.require:
315  */
316 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_01, TestSize.Level1)
317 {
318     CALL_TEST_DEBUG;
319     EventInterceptorHandler::InterceptorCollection interceptorHandler;
320     InputHandlerType handlerType = InputHandlerType::NONE;
321     HandleEventType eventType = 0;
322     int32_t priority = 0;
323     uint32_t deviceTags = 0;
324     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
325         g_writeFd, UID_ROOT, g_pid);
326     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
327         deviceTags, sessionFirst);
328 
329     handlerType = InputHandlerType::NONE;
330     eventType = 0;
331     priority = 0;
332     deviceTags = 0;
333     SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
334         g_writeFd, UID_ROOT, g_pid);
335     EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
336         deviceTags, sessionSecond);
337     interceptorHandler.interceptors_.push_back(interceptorSecond);
338     ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
339 }
340 
341 /**
342  * @tc.name: EventInterceptorHandler_RemoveInterceptor_02
343  * @tc.desc: Test RemoveInterceptor
344  * @tc.type: FUNC
345  * @tc.require:
346  */
347 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_02, TestSize.Level1)
348 {
349     CALL_TEST_DEBUG;
350     EventInterceptorHandler::InterceptorCollection interceptorHandler;
351     InputHandlerType handlerType = InputHandlerType::NONE;
352     HandleEventType eventType = 0;
353     int32_t priority = 0;
354     uint32_t deviceTags = 0;
355     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
356         g_writeFd, UID_ROOT, g_pid);
357     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
358         deviceTags, sessionFirst);
359     interceptorHandler.interceptors_.push_back(interceptorFirst);
360     ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
361 }
362 
363 /**
364  * @tc.name: EventInterceptorHandler_RemoveInterceptor_03
365  * @tc.desc: Test RemoveInterceptor
366  * @tc.type: FUNC
367  * @tc.require:
368  */
369 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_03, TestSize.Level1)
370 {
371     CALL_TEST_DEBUG;
372     EventInterceptorHandler::InterceptorCollection interceptorHandler;
373     InputHandlerType handlerType = InputHandlerType::NONE;
374     HandleEventType eventType = 1;
375     int32_t priority = 1;
376     uint32_t deviceTags = 0;
377     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
378         g_writeFd, UID_ROOT, g_pid);
379     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
380         deviceTags, sessionFirst);
381 
382     handlerType = InputHandlerType::NONE;
383     eventType = 1;
384     priority = 2;
385     deviceTags = 0;
386     SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
387         g_writeFd, UID_ROOT, g_pid);
388     EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
389         deviceTags, sessionSecond);
390     interceptorHandler.interceptors_.push_back(interceptorSecond);
391     ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
392 }
393 
394 /**
395  * @tc.name: EventInterceptorHandler_RemoveInterceptor_04
396  * @tc.desc: Test RemoveInterceptor
397  * @tc.type: FUNC
398  * @tc.require:
399  */
400 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_04, TestSize.Level1)
401 {
402     CALL_TEST_DEBUG;
403     EventInterceptorHandler::InterceptorCollection interceptorHandler;
404     InputHandlerType handlerType = InputHandlerType::NONE;
405     HandleEventType eventType = 1;
406     int32_t priority = 1;
407     uint32_t deviceTags = 0;
408     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
409         g_writeFd, UID_ROOT, g_pid);
410     EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
411         deviceTags, sessionFirst);
412 
413     handlerType = InputHandlerType::NONE;
414     eventType = 1;
415     priority = 0;
416     deviceTags = 0;
417     SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
418         g_writeFd, UID_ROOT, g_pid);
419     EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
420         deviceTags, sessionSecond);
421     interceptorHandler.interceptors_.push_back(interceptorSecond);
422     ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
423 }
424 
425 /**
426  * @tc.name: EventInterceptorHandler_OnSessionLost_01
427  * @tc.desc: Test OnSessionLost
428  * @tc.type: FUNC
429  * @tc.require:
430  */
431 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_OnSessionLost_01, TestSize.Level1)
432 {
433     CALL_TEST_DEBUG;
434     EventInterceptorHandler::InterceptorCollection interceptorHandler;
435     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
436         g_writeFd, UID_ROOT, g_pid);
437     SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
438         g_writeFd, UID_ROOT, g_pid);
439     InputHandlerType handlerType = InputHandlerType::NONE;
440     HandleEventType eventType = 0;
441     int32_t priority = 0;
442     uint32_t deviceTags = 0;
443     SessionPtr session = sessionSecond;
444     EventInterceptorHandler::SessionHandler interceptor(handlerType, eventType, priority,
445         deviceTags, session);
446     interceptorHandler.interceptors_.push_back(interceptor);
447     ASSERT_NO_FATAL_FAILURE(interceptorHandler.OnSessionLost(sessionFirst));
448 }
449 
450 /**
451  * @tc.name: EventInterceptorHandler_OnSessionLost_02
452  * @tc.desc: Test OnSessionLost
453  * @tc.type: FUNC
454  * @tc.require:
455  */
456 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_OnSessionLost_02, TestSize.Level1)
457 {
458     CALL_TEST_DEBUG;
459     EventInterceptorHandler::InterceptorCollection interceptorHandler;
460     SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
461         g_writeFd, UID_ROOT, g_pid);
462     InputHandlerType handlerType = InputHandlerType::NONE;
463     HandleEventType eventType = 0;
464     int32_t priority = 0;
465     uint32_t deviceTags = 0;
466     SessionPtr session = sessionFirst;
467     EventInterceptorHandler::SessionHandler interceptor(handlerType, eventType, priority,
468         deviceTags, session);
469     interceptorHandler.interceptors_.push_back(interceptor);
470     ASSERT_NO_FATAL_FAILURE(interceptorHandler.OnSessionLost(sessionFirst));
471 }
472 
473 /**
474  * @tc.name: EventInterceptorHandler_AddInputHandler_001
475  * @tc.desc: Test the function AddInputHandler
476  * @tc.type: FUNC
477  * @tc.require:
478  */
479 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInputHandler_001, TestSize.Level1)
480 {
481     CALL_TEST_DEBUG;
482     EventInterceptorHandler handler;
483     SessionPtr sess = nullptr;
484     InputHandlerType handlerType = InputHandlerType::NONE;
485     HandleEventType eventType = HANDLE_EVENT_TYPE_NONE;
486     int32_t priority = 2;
487     uint32_t deviceTags = 3;
488     int32_t ret = handler.AddInputHandler(handlerType, eventType, priority, deviceTags, sess);
489     EXPECT_EQ(ret, RET_ERR);
490     sess = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid);
491     ret = handler.AddInputHandler(handlerType, eventType, priority, deviceTags, sess);
492     EXPECT_EQ(ret, RET_ERR);
493     eventType = HANDLE_EVENT_TYPE_KEY;
494     ret = handler.AddInputHandler(handlerType, eventType, priority, deviceTags, sess);
495     EXPECT_EQ(ret, RET_OK);
496 }
497 
498 /**
499  * @tc.name: EventInterceptorHandler_RemoveInputHandler_001
500  * @tc.desc: Test the function RemoveInputHandler
501  * @tc.type: FUNC
502  * @tc.require:
503  */
504 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInputHandler_001, TestSize.Level1)
505 {
506     CALL_TEST_DEBUG;
507     EventInterceptorHandler handler;
508     InputHandlerType handlerType = InputHandlerType::INTERCEPTOR;
509     HandleEventType eventType = 1;
510     int32_t priority = 2;
511     uint32_t deviceTags = 1;
512     SessionPtr session = nullptr;
513     ASSERT_NO_FATAL_FAILURE(handler.RemoveInputHandler(handlerType, eventType, priority, deviceTags, session));
514     session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid);
515     ASSERT_NO_FATAL_FAILURE(handler.RemoveInputHandler(handlerType, eventType, priority, deviceTags, session));
516 }
517 
518 /**
519  * @tc.name: EventInterceptorHandler_RemoveInputHandler_002
520  * @tc.desc: Test the function RemoveInputHandler
521  * @tc.type: FUNC
522  * @tc.require:
523  */
524 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInputHandler_002, TestSize.Level1)
525 {
526     CALL_TEST_DEBUG;
527     EventInterceptorHandler handler;
528     InputHandlerType handlerType = InputHandlerType::NONE;
529     HandleEventType eventType = 1;
530     int32_t priority = 2;
531     uint32_t deviceTags = 1;
532     SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid);
533     ASSERT_NO_FATAL_FAILURE(handler.RemoveInputHandler(handlerType, eventType, priority, deviceTags, session));
534     handlerType = InputHandlerType::MONITOR;
535     ASSERT_NO_FATAL_FAILURE(handler.RemoveInputHandler(handlerType, eventType, priority, deviceTags, session));
536 }
537 
538 /**
539  * @tc.name: EventInterceptorHandler_InitSessionLostCallback_001
540  * @tc.desc: Test the function InitSessionLostCallback
541  * @tc.type: FUNC
542  * @tc.require:
543  */
544 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_InitSessionLostCallback_001, TestSize.Level1)
545 {
546     CALL_TEST_DEBUG;
547     EventInterceptorHandler handler;
548     handler.sessionLostCallbackInitialized_ = true;
549     ASSERT_NO_FATAL_FAILURE(handler.InitSessionLostCallback());
550     handler.sessionLostCallbackInitialized_ = false;
551     ASSERT_NO_FATAL_FAILURE(handler.InitSessionLostCallback());
552 }
553 
554 /**
555  * @tc.name: EventInterceptorHandler_SendToClient_keyEvent_001
556  * @tc.desc: Test the function SendToClient,parameter is keyEvent
557  * @tc.type: FUNC
558  * @tc.require:
559  */
560 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_SendToClient_keyEvent_001, TestSize.Level1)
561 {
562     CALL_TEST_DEBUG;
563     InputHandlerType handlerType = InputHandlerType::NONE;
564     HandleEventType eventType = 0;
565     int32_t priority = 1;
566     uint32_t deviceTags = 0x01;
567     SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid);
568     EventInterceptorHandler::SessionHandler sessionHandler { handlerType, eventType, priority, deviceTags, session };
569     std::shared_ptr<KeyEvent> keyEvent = nullptr;
570     ASSERT_NO_FATAL_FAILURE(sessionHandler.SendToClient(keyEvent));
571     keyEvent = KeyEvent::Create();
572     ASSERT_NE(keyEvent, nullptr);
573     ASSERT_NO_FATAL_FAILURE(sessionHandler.SendToClient(keyEvent));
574 }
575 
576 /**
577  * @tc.name: EventInterceptorHandler_SendToClient_pointerEvent_001
578  * @tc.desc: Test the function SendToClient,parameter is pointerEvent
579  * @tc.type: FUNC
580  * @tc.require:
581  */
582 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_SendToClient_pointerEvent_001, TestSize.Level1)
583 {
584     CALL_TEST_DEBUG;
585     InputHandlerType handlerType = InputHandlerType::NONE;
586     HandleEventType eventType = 0;
587     int32_t priority = 1;
588     uint32_t deviceTags = 0x01;
589     SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid);
590     EventInterceptorHandler::SessionHandler sessionHandler { handlerType, eventType, priority, deviceTags, session };
591     std::shared_ptr<PointerEvent> pointerEvent = nullptr;
592     ASSERT_NO_FATAL_FAILURE(sessionHandler.SendToClient(pointerEvent));
593     pointerEvent = PointerEvent::Create();
594     ASSERT_NE(pointerEvent, nullptr);
595     ASSERT_NO_FATAL_FAILURE(sessionHandler.SendToClient(pointerEvent));
596 }
597 } // namespace MMI
598 } // namespace OHOS
599