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
598 /**
599 * @tc.name: KeyInterceptByHostOSWhiteList_001
600 * @tc.desc: Test the function KeyInterceptByHostOSWhiteList
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(EventInterceptorHandlerTest, KeyInterceptByHostOSWhiteList_001, TestSize.Level1)
605 {
606 CALL_TEST_DEBUG;
607 EventInterceptorHandler handler;
608 handler.keyevent_intercept_whitelist = nullptr;
609 int32_t keyCode = 123;
610 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
611 handler.keyevent_intercept_whitelist = std::make_unique<std::string>("");
612 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
613 }
614
615 /**
616 * @tc.name: KeyInterceptByHostOSWhiteList_002
617 * @tc.desc: Test the function KeyInterceptByHostOSWhiteList
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(EventInterceptorHandlerTest, KeyInterceptByHostOSWhiteList_002, TestSize.Level1)
622 {
623 CALL_TEST_DEBUG;
624 EventInterceptorHandler handler;
625 int32_t keyCode = 123;
626 handler.keyevent_intercept_whitelist = std::make_unique<std::string>("123;456;");
627 EXPECT_TRUE(handler.KeyInterceptByHostOSWhiteList(keyCode));
628 }
629
630 /**
631 * @tc.name: KeyInterceptByHostOSWhiteList_003
632 * @tc.desc: Test the function KeyInterceptByHostOSWhiteList
633 * @tc.type: FUNC
634 * @tc.require:
635 */
636 HWTEST_F(EventInterceptorHandlerTest, KeyInterceptByHostOSWhiteList_003, TestSize.Level1)
637 {
638 CALL_TEST_DEBUG;
639 EventInterceptorHandler handler;
640 int32_t keyCode = 789;
641 handler.keyevent_intercept_whitelist = std::make_unique<std::string>("123;456;");
642 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
643 }
644
645 /**
646 * @tc.name: EventInterceptorHandler_Test_011
647 * @tc.desc: Test the function HandleEvent
648 * @tc.type: FUNC
649 * @tc.require:
650 */
651 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_011, TestSize.Level1)
652 {
653 CALL_TEST_DEBUG;
654 EventInterceptorHandler::InterceptorCollection interceptorHandler;
655 InputHandlerType handlerType = InputHandlerType::NONE;
656 HandleEventType eventType = 0;
657 int32_t priority = 0;
658 uint32_t deviceTags = 0;
659 // SessionPtr session = std::make_shared<SessionPtr>();
660 EventInterceptorHandler::SessionHandler sessionHandler(handlerType, eventType, priority, deviceTags, nullptr);
661 interceptorHandler.interceptors_.push_back(sessionHandler);
662 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
663 bool ret = interceptorHandler.HandleEvent(pointerEvent);
664 EXPECT_FALSE(ret);
665 }
666
667 /**
668 * @tc.name: TouchPadKnuckleDoubleClickHandle_Test_001
669 * @tc.desc: Test the function TouchPadKnuckleDoubleClickHandle
670 * @tc.type: FUNC
671 * @tc.require:
672 */
673 HWTEST_F(EventInterceptorHandlerTest, TouchPadKnuckleDoubleClickHandle_Test_001, TestSize.Level1)
674 {
675 CALL_TEST_DEBUG;
676 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
677 event->SetKeyAction(KNUCKLE_1F_DOUBLE_CLICK); // or KNUCKLE_2F_DOUBLE_CLICK
678 EventInterceptorHandler handler;
679 handler.nextHandler_ = std::make_shared<EventInterceptorHandler>();
680 bool result = handler.TouchPadKnuckleDoubleClickHandle(event);
681 EXPECT_TRUE(result);
682 }
683
684 /**
685 * @tc.name: TouchPadKnuckleDoubleClickHandle_Test_002
686 * @tc.desc: Test the function TouchPadKnuckleDoubleClickHandle
687 * @tc.type: FUNC
688 * @tc.require:
689 */
690 HWTEST_F(EventInterceptorHandlerTest, TouchPadKnuckleDoubleClickHandle_Test_002, TestSize.Level1)
691 {
692 CALL_TEST_DEBUG;
693 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
694 int32_t keyAction = 123;
695 event->SetKeyAction(keyAction); // Not a double click action
696 EventInterceptorHandler handler;
697 bool result = handler.TouchPadKnuckleDoubleClickHandle(event);
698 EXPECT_FALSE(result);
699 }
700
701 /**
702 * @tc.name: TouchPadKnuckleDoubleClickHandle_Test_003
703 * @tc.desc: Test the function TouchPadKnuckleDoubleClickHandle
704 * @tc.type: FUNC
705 * @tc.require:
706 */
707 HWTEST_F(EventInterceptorHandlerTest, TouchPadKnuckleDoubleClickHandle_Test_003, TestSize.Level1)
708 {
709 CALL_TEST_DEBUG;
710 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
711 event->SetKeyAction(KNUCKLE_2F_DOUBLE_CLICK); // or KNUCKLE_2F_DOUBLE_CLICK
712 EventInterceptorHandler handler;
713 handler.nextHandler_ = std::make_shared<EventInterceptorHandler>();
714 bool result = handler.TouchPadKnuckleDoubleClickHandle(event);
715 EXPECT_TRUE(result);
716 }
717
718 /**
719 * @tc.name: EventInterceptorHandler_Test_0011
720 * @tc.desc: Test the function HandleKeyEvent
721 * @tc.type: FUNC
722 * @tc.require:
723 */
724 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0011, TestSize.Level1)
725 {
726 CALL_TEST_DEBUG;
727 EventInterceptorHandler handler;
728 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
729 event->SetKeyAction(KNUCKLE_2F_DOUBLE_CLICK);
730 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(event));
731 }
732
733 /**
734 * @tc.name: EventInterceptorHandler_Test_0018
735 * @tc.desc: Test the function TouchPadKnuckleDoubleClickHandle
736 * @tc.type: FUNC
737 * @tc.require:
738 */
739 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0018, TestSize.Level1)
740 {
741 CALL_TEST_DEBUG;
742 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
743 int32_t keyAction = 123;
744 event->SetKeyAction(keyAction); // or KNUCKLE_2F_DOUBLE_CLICK
745 EventInterceptorHandler handler;
746 handler.nextHandler_ = std::make_shared<EventInterceptorHandler>();
747 ASSERT_NO_FATAL_FAILURE(handler.TouchPadKnuckleDoubleClickHandle(event));
748 }
749
750 /**
751 * @tc.name: EventInterceptorHandler_Test_0019
752 * @tc.desc: Test the function HandlePointerEvent
753 * @tc.type: FUNC
754 * @tc.require:
755 */
756 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0019, TestSize.Level1)
757 {
758 CALL_TEST_DEBUG;
759 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
760 auto InputEvent = InputEvent::Create();
761 ASSERT_NE(InputEvent, nullptr);
762 InputEvent->ClearFlag();
763 uint32_t flag = 1;
764 InputEvent->AddFlag(flag);
765 EventInterceptorHandler handler;
766 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
767 }
768
TestCapabilityToTags(InputDeviceCapability capability)769 static uint32_t TestCapabilityToTags(InputDeviceCapability capability)
770 {
771 return static_cast<uint32_t>((1 << capability) - (capability / INPUT_DEV_CAP_MAX));
772 }
773
774 /**
775 * @tc.name: EventInterceptorHandler_Test_0020
776 * @tc.desc: Test the function CheckInputDeviceSource
777 * @tc.type: FUNC
778 * @tc.require:
779 */
780 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0020, TestSize.Level1)
781 {
782 CALL_TEST_DEBUG;
783 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
784 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
785 uint32_t deviceTags = TestCapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_TOUCH);
786 bool ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
787 EXPECT_EQ(ret, true);
788 deviceTags = TestCapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_TABLET_TOOL);
789 ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
790 EXPECT_EQ(ret, true);
791 deviceTags = 0;
792 ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
793 EXPECT_EQ(ret, false);
794
795 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
796 deviceTags = TestCapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_POINTER);
797 ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
798 EXPECT_EQ(ret, true);
799 deviceTags = TestCapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_TOUCH);
800 ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
801 EXPECT_EQ(ret, false);
802
803 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
804 deviceTags = TestCapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_POINTER);
805 ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
806 EXPECT_EQ(ret, true);
807 deviceTags = TestCapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_TOUCH);
808 ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
809 EXPECT_EQ(ret, false);
810
811 pointerEvent->SetSourceType(0);
812 deviceTags = TestCapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_POINTER);
813 ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
814 EXPECT_EQ(ret, false);
815 deviceTags = TestCapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_TOUCH);
816 ret = EventInterceptorHandler::CheckInputDeviceSource(pointerEvent, deviceTags);
817 EXPECT_EQ(ret, false);
818 }
819
820 /**
821 * @tc.name: EventInterceptorHandler_Test_0021
822 * @tc.desc: Test the function HandleEvent when ENABLE_KEYBOARD
823 * @tc.type: FUNC
824 * @tc.require:
825 */
826 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0021, TestSize.Level1)
827 {
828 CALL_TEST_DEBUG;
829 InputHandlerType handlerType = InputHandlerType::NONE;
830 HandleEventType eventType = HANDLE_EVENT_TYPE_NONE;
831 int32_t priority = 0;
832 uint32_t deviceTags = 0;
833 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
834 g_writeFd, UID_ROOT, g_pid);
835 EventInterceptorHandler::SessionHandler interceptor(handlerType, eventType, priority,
836 deviceTags, session);
837 EventInterceptorHandler::InterceptorCollection interceptorHandler;
838 interceptorHandler.interceptors_.push_back(interceptor);
839 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
840 bool ret = interceptorHandler.HandleEvent(keyEvent);
841 EXPECT_EQ(ret, false);
842
843 KeyEvent::KeyItem item;
844 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
845 item.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
846 item.SetDownTime(200);
847 keyEvent->AddKeyItem(item);
848 ret = interceptorHandler.HandleEvent(keyEvent);
849 EXPECT_EQ(ret, false);
850 }
851
852 /**
853 * @tc.name: EventInterceptorHandler_Test_0022
854 * @tc.desc: Test the function HandleEvent when ENABLE_KEYBOARD
855 * @tc.type: FUNC
856 * @tc.require:
857 */
858 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0022, TestSize.Level1)
859 {
860 CALL_TEST_DEBUG;
861 InputHandlerType handlerType = InputHandlerType::NONE;
862 HandleEventType eventType = HANDLE_EVENT_TYPE_KEY;
863 int32_t priority = 0;
864 uint32_t deviceTags = INPUT_DEV_CAP_KEYBOARD;
865 EventInterceptorHandler::SessionHandler interceptor(handlerType, eventType, priority,
866 deviceTags, nullptr);
867 EventInterceptorHandler::InterceptorCollection interceptorHandler;
868 interceptorHandler.interceptors_.push_back(interceptor);
869 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
870 KeyEvent::KeyItem item;
871 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
872 item.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
873 item.SetDownTime(200);
874 keyEvent->AddKeyItem(item);
875
876 bool ret = interceptorHandler.HandleEvent(keyEvent);
877 EXPECT_EQ(ret, false);
878 }
879
880 /**
881 * @tc.name: EventInterceptorHandler_Test_0023
882 * @tc.desc: Test the function HandleEvent when ENABLE_KEYBOARD
883 * @tc.type: FUNC
884 * @tc.require:
885 */
886 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0023, TestSize.Level1)
887 {
888 CALL_TEST_DEBUG;
889 InputHandlerType handlerType = InputHandlerType::NONE;
890 HandleEventType eventType = HANDLE_EVENT_TYPE_KEY;
891 int32_t priority = 0;
892 uint32_t deviceTags = INPUT_DEV_CAP_TOUCH;
893 EventInterceptorHandler::SessionHandler interceptor(handlerType, eventType, priority,
894 deviceTags, nullptr);
895 EventInterceptorHandler::InterceptorCollection interceptorHandler;
896 interceptorHandler.interceptors_.push_back(interceptor);
897 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
898 KeyEvent::KeyItem item;
899 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
900 item.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
901 item.SetDownTime(200);
902 keyEvent->AddKeyItem(item);
903
904 bool ret = interceptorHandler.HandleEvent(keyEvent);
905 EXPECT_EQ(ret, false);
906 }
907
908 /**
909 * @tc.name: EventInterceptorHandler_Test_0024
910 * @tc.desc: Test the function HandleEvent when ENABLE_KEYBOARD
911 * @tc.type: FUNC
912 * @tc.require:
913 */
914 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0024, TestSize.Level1)
915 {
916 CALL_TEST_DEBUG;
917 InputHandlerType handlerType = InputHandlerType::NONE;
918 HandleEventType eventType = HANDLE_EVENT_TYPE_KEY;
919 int32_t priority = 0;
920 uint32_t deviceTags = INPUT_DEV_CAP_KEYBOARD;
921 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
922 g_writeFd, UID_ROOT, g_pid);
923 EventInterceptorHandler::SessionHandler interceptor(handlerType, eventType, priority,
924 deviceTags, session);
925 EventInterceptorHandler::InterceptorCollection interceptorHandler;
926 interceptorHandler.interceptors_.push_back(interceptor);
927 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
928 KeyEvent::KeyItem item;
929 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
930 item.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
931 item.SetDownTime(200);
932 keyEvent->AddKeyItem(item);
933
934 ASSERT_NO_FATAL_FAILURE(interceptorHandler.HandleEvent(keyEvent));
935 }
936
937 /**
938 * @tc.name: EventInterceptorHandler_Test_0025
939 * @tc.desc: Test the function HandleEvent when ENABLE_KEYBOARD
940 * @tc.type: FUNC
941 * @tc.require:
942 */
943 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0025, TestSize.Level1)
944 {
945 CALL_TEST_DEBUG;
946 InputHandlerType handlerType = InputHandlerType::NONE;
947 HandleEventType eventType = HANDLE_EVENT_TYPE_NONE;
948 int32_t priority = 0;
949 uint32_t deviceTags = INPUT_DEV_CAP_KEYBOARD;
950 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
951 g_writeFd, UID_ROOT, g_pid);
952 EventInterceptorHandler::SessionHandler interceptor(handlerType, eventType, priority,
953 deviceTags, session);
954 EventInterceptorHandler::InterceptorCollection interceptorHandler;
955 interceptorHandler.interceptors_.push_back(interceptor);
956 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
957 KeyEvent::KeyItem item;
958 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
959 item.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
960 item.SetDownTime(200);
961 keyEvent->AddKeyItem(item);
962
963 bool ret = interceptorHandler.HandleEvent(keyEvent);
964 EXPECT_EQ(ret, false);
965 }
966
967 /**
968 * @tc.name: EventInterceptorHandler_Test_0026
969 * @tc.desc: Test the function HandleEvent when ENABLE_KEYBOARD
970 * @tc.type: FUNC
971 * @tc.require:
972 */
973 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0026, TestSize.Level1)
974 {
975 CALL_TEST_DEBUG;
976 InputHandlerType handlerType = InputHandlerType::NONE;
977 HandleEventType eventType = HANDLE_EVENT_TYPE_NONE;
978 int32_t priority = 0;
979 uint32_t deviceTags = 0;
980 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
981 g_writeFd, UID_ROOT, g_pid);
982 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
983 deviceTags, sessionFirst);
984 EventInterceptorHandler::InterceptorCollection interceptorHandler;
985 interceptorHandler.interceptors_.push_back(interceptorFirst);
986 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
987 bool ret = interceptorHandler.HandleEvent(pointerEvent);
988 EXPECT_EQ(ret, false);
989
990 PointerEvent::PointerItem item;
991 item.SetPointerId(0);
992 pointerEvent->AddPointerItem(item);
993 ret = interceptorHandler.HandleEvent(pointerEvent);
994 EXPECT_EQ(ret, false);
995 }
996
997 /**
998 * @tc.name: EventInterceptorHandler_Test_0027
999 * @tc.desc: Test the function HandleEvent when ENABLE_KEYBOARD
1000 * @tc.type: FUNC
1001 * @tc.require:
1002 */
1003 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0027, TestSize.Level1)
1004 {
1005 CALL_TEST_DEBUG;
1006 InputHandlerType handlerType = InputHandlerType::NONE;
1007 HandleEventType eventType = HANDLE_EVENT_TYPE_NONE;
1008 int32_t priority = 0;
1009 uint32_t deviceTags = 0;
1010 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1011 deviceTags, nullptr);
1012 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1013 interceptorHandler.interceptors_.push_back(interceptorFirst);
1014 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1015
1016 PointerEvent::PointerItem item;
1017 item.SetPointerId(0);
1018 pointerEvent->AddPointerItem(item);
1019 bool ret = interceptorHandler.HandleEvent(pointerEvent);
1020 EXPECT_EQ(ret, false);
1021 }
1022
1023 /**
1024 * @tc.name: EventInterceptorHandler_Test_0028
1025 * @tc.desc: Test the function HandleEvent when ENABLE_KEYBOARD
1026 * @tc.type: FUNC
1027 * @tc.require:
1028 */
1029 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_Test_0028, TestSize.Level1)
1030 {
1031 CALL_TEST_DEBUG;
1032 InputHandlerType handlerType = InputHandlerType::NONE;
1033 HandleEventType eventType = HANDLE_EVENT_TYPE_POINTER;
1034 int32_t priority = 0;
1035 uint32_t deviceTags = 0;
1036 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1037 g_writeFd, UID_ROOT, g_pid);
1038 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1039 deviceTags, sessionFirst);
1040 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1041 interceptorHandler.interceptors_.push_back(interceptorFirst);
1042 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1043
1044 PointerEvent::PointerItem item;
1045 item.SetPointerId(0);
1046 pointerEvent->AddPointerItem(item);
1047 bool ret = interceptorHandler.HandleEvent(pointerEvent);
1048 EXPECT_EQ(ret, false);
1049 }
1050
1051 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1052 /**
1053 * @tc.name: EventInterceptorHandler_HandleKeyEvent_002
1054 * @tc.desc: Test the function HandleKeyEvent WhenDoubleClickDetected
1055 * @tc.type: FUNC
1056 * @tc.require:
1057 */
1058 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_HandleKeyEvent_002, TestSize.Level1)
1059 {
1060 CALL_TEST_DEBUG;
1061 EventInterceptorHandler handler;
1062 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
1063 handler.nextHandler_ = std::make_shared<EventInterceptorHandler>();
1064 event->SetKeyAction(KNUCKLE_2F_DOUBLE_CLICK);
1065 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(event));
1066 }
1067
1068 /**
1069 * @tc.name: EventInterceptorHandler_HandleKeyEvent_003
1070 * @tc.desc: Test the function HandleKeyEvent WhenDoubleClickDetected
1071 * @tc.type: FUNC
1072 * @tc.require:
1073 */
1074 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_HandleKeyEvent_003, TestSize.Level1)
1075 {
1076 CALL_TEST_DEBUG;
1077 EventInterceptorHandler handler;
1078 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
1079 handler.nextHandler_ = std::make_shared<EventInterceptorHandler>();
1080 event->SetKeyAction(KNUCKLE_1F_DOUBLE_CLICK);
1081 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(event));
1082 }
1083
1084 /**
1085 * @tc.name: EventInterceptorHandler_HandleKeyEvent_004
1086 * @tc.desc: Test the function HandleKeyEvent WhenKeyInWhiteList
1087 * @tc.type: FUNC
1088 * @tc.require:
1089 */
1090 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_HandleKeyEvent_004, TestSize.Level1)
1091 {
1092 CALL_TEST_DEBUG;
1093 EventInterceptorHandler handler;
1094 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
1095 handler.nextHandler_ = std::make_shared<EventInterceptorHandler>();
1096 event->SetKeyAction(INPUT_DEVICE_AISENSOR);
1097 int32_t keyCode = 123;
1098 handler.keyevent_intercept_whitelist = std::make_unique<std::string>("123;456;");
1099 EXPECT_TRUE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1100 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(event));
1101 }
1102
1103 /**
1104 * @tc.name: EventInterceptorHandler_HandleKeyEvent_005
1105 * @tc.desc: Test the function HandleKeyEvent WhenKeyNotInWhiteListAndNotOnHandleEvent
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
1109 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_HandleKeyEvent_005, TestSize.Level1)
1110 {
1111 CALL_TEST_DEBUG;
1112 EventInterceptorHandler handler;
1113 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
1114 handler.nextHandler_ = std::make_shared<EventInterceptorHandler>();
1115 event->SetKeyAction(INPUT_DEVICE_AISENSOR);
1116 handler.keyevent_intercept_whitelist = nullptr;
1117 int32_t keyCode = 123;
1118 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1119 handler.keyevent_intercept_whitelist = std::make_unique<std::string>("");
1120 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1121 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(event));
1122 }
1123
1124 /**
1125 * @tc.name: EventInterceptorHandler_HandleKeyEvent_006
1126 * @tc.desc: Test the function HandleKeyEvent WhenKeyNotInWhiteList
1127 * @tc.type: FUNC
1128 * @tc.require:
1129 */
1130 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_HandleKeyEvent_006, TestSize.Level1)
1131 {
1132 CALL_TEST_DEBUG;
1133 EventInterceptorHandler handler;
1134 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
1135 handler.nextHandler_ = std::make_shared<EventInterceptorHandler>();
1136 event->SetKeyAction(INPUT_DEVICE_AISENSOR);
1137 int32_t keyCode = 789;
1138 handler.keyevent_intercept_whitelist = std::make_unique<std::string>("123;456;");
1139 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1140 event->bitwise_ = 0x00000000;
1141 EXPECT_FALSE(handler.OnHandleEvent(event));
1142 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(event));
1143 }
1144
1145 /**
1146 * @tc.name: EventInterceptorHandler_OnHandleEvent_001
1147 * @tc.desc: Test the function OnHandleEvent_001
1148 * @tc.type: FUNC
1149 * @tc.require:
1150 */
1151 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_OnHandleEvent_001, TestSize.Level1)
1152 {
1153 CALL_TEST_DEBUG;
1154 EventInterceptorHandler handler;
1155 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
1156 event->bitwise_ = 0x00000001;
1157 EXPECT_FALSE(handler.OnHandleEvent(event));
1158 }
1159
1160 /**
1161 * @tc.name: EventInterceptorHandler_OnHandleEvent_002
1162 * @tc.desc: Test the function OnHandleEvent_002
1163 * @tc.type: FUNC
1164 * @tc.require:
1165 */
1166 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_OnHandleEvent_002, TestSize.Level1)
1167 {
1168 CALL_TEST_DEBUG;
1169 EventInterceptorHandler handler;
1170 std::shared_ptr<KeyEvent> event = KeyEvent::Create();
1171 event->bitwise_ = 0x00000000;
1172 EXPECT_FALSE(handler.OnHandleEvent(event));
1173 }
1174
1175 /**
1176 * @tc.name: EventInterceptorHandler_OnHandleEvent_003
1177 * @tc.desc: Test the function OnHandleEvent_003
1178 * @tc.type: FUNC
1179 * @tc.require:
1180 */
1181 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_OnHandleEvent_003, TestSize.Level1)
1182 {
1183 CALL_TEST_DEBUG;
1184 EventInterceptorHandler handler;
1185 std::shared_ptr<PointerEvent> event = PointerEvent::Create();
1186 event->bitwise_ = 0x00000001;
1187 EXPECT_FALSE(handler.OnHandleEvent(event));
1188 }
1189
1190 /**
1191 * @tc.name: EventInterceptorHandler_OnHandleEvent_004
1192 * @tc.desc: Test the function OnHandleEvent_004
1193 * @tc.type: FUNC
1194 * @tc.require:
1195 */
1196 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_OnHandleEvent_004, TestSize.Level1)
1197 {
1198 CALL_TEST_DEBUG;
1199 EventInterceptorHandler handler;
1200 std::shared_ptr<PointerEvent> event = PointerEvent::Create();
1201 event->bitwise_ = 0x0000000;
1202 EXPECT_FALSE(handler.OnHandleEvent(event));
1203 }
1204
1205 /**
1206 * @tc.name: KeyInterceptByHostOSWhiteList_004
1207 * @tc.desc: Test the function KeyInterceptByHostOSWhiteList
1208 * @tc.type: FUNC
1209 * @tc.require:
1210 */
1211 HWTEST_F(EventInterceptorHandlerTest, KeyInterceptByHostOSWhiteList_004, TestSize.Level1)
1212 {
1213 CALL_TEST_DEBUG;
1214 EventInterceptorHandler handler;
1215 handler.keyevent_intercept_whitelist = nullptr;
1216 int32_t keyCode = 123;
1217 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1218 keyCode = 78;
1219 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1220 keyCode = 789;
1221 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1222 }
1223
1224 /**
1225 * @tc.name: KeyInterceptByHostOSWhiteList_005
1226 * @tc.desc: Test the function KeyInterceptByHostOSWhiteList
1227 * @tc.type: FUNC
1228 * @tc.require:
1229 */
1230 HWTEST_F(EventInterceptorHandlerTest, KeyInterceptByHostOSWhiteList_005, TestSize.Level1)
1231 {
1232 CALL_TEST_DEBUG;
1233 EventInterceptorHandler handler;
1234 handler.keyevent_intercept_whitelist.reset();
1235 handler.keyevent_intercept_whitelist = std::make_unique<std::string>("2722;41;40;0;22;17;16;23;2841;9;2089;2083;");
1236 int32_t keyCode = 2722;
1237 EXPECT_TRUE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1238 keyCode = 41;
1239 EXPECT_TRUE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1240 keyCode = 42;
1241 EXPECT_FALSE(handler.KeyInterceptByHostOSWhiteList(keyCode));
1242 }
1243 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1244
1245 /**
1246 * @tc.name: EventInterceptorHandler_InitSessionLostCallback_002
1247 * @tc.desc: Test the function InitSessionLostCallback
1248 * @tc.type: FUNC
1249 * @tc.require:
1250 */
1251 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_InitSessionLostCallback_002, TestSize.Level1)
1252 {
1253 CALL_TEST_DEBUG;
1254 EventInterceptorHandler handler;
1255 ASSERT_NO_FATAL_FAILURE(handler.InitSessionLostCallback());
1256 }
1257
1258 /**
1259 * @tc.name: EventInterceptorHandler_InitSessionLostCallback_003
1260 * @tc.desc: Test the function InitSessionLostCallback
1261 * @tc.type: FUNC
1262 * @tc.require:
1263 */
1264 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_InitSessionLostCallback_003, TestSize.Level1)
1265 {
1266 CALL_TEST_DEBUG;
1267 EventInterceptorHandler handler;
1268 handler.sessionLostCallbackInitialized_ = false;
1269 EXPECT_FALSE(handler.sessionLostCallbackInitialized_);
1270 ASSERT_NO_FATAL_FAILURE(handler.InitSessionLostCallback());
1271 }
1272
1273 /**
1274 * @tc.name: EventInterceptorHandler_AddInterceptor_05
1275 * @tc.desc: Test AddInterceptor
1276 * @tc.type: FUNC
1277 * @tc.require:
1278 */
1279 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_05, TestSize.Level1)
1280 {
1281 CALL_TEST_DEBUG;
1282 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1283 InputHandlerType handlerType = InputHandlerType::INTERCEPTOR;
1284 HandleEventType eventType = 0;
1285 int32_t priority = 1;
1286 uint32_t deviceTags = 0;
1287 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1288 g_writeFd, UID_ROOT, g_pid);
1289 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1290 deviceTags, sessionFirst);
1291 handlerType = InputHandlerType::INTERCEPTOR;
1292 eventType = 0;
1293 priority = 2;
1294 deviceTags = 0;
1295 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1296 g_writeFd, UID_ROOT, g_pid);
1297 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1298 deviceTags, sessionSecond);
1299 for (int32_t i = 0; i < MAX_N_INPUT_INTERCEPTORS; i++) {
1300 interceptorHandler.interceptors_.push_back(interceptorSecond);
1301 }
1302 int32_t result = interceptorHandler.AddInterceptor(interceptorFirst);
1303 EXPECT_EQ(result, RET_ERR);
1304 ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
1305 }
1306
1307 /**
1308 * @tc.name: EventInterceptorHandler_AddInterceptor_06
1309 * @tc.desc: Test AddInterceptor
1310 * @tc.type: FUNC
1311 * @tc.require:
1312 */
1313 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_06, TestSize.Level1)
1314 {
1315 CALL_TEST_DEBUG;
1316 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1317 InputHandlerType handlerType = InputHandlerType::MONITOR;
1318 HandleEventType eventType = 0;
1319 int32_t priority = 1;
1320 uint32_t deviceTags = 0;
1321 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1322 g_writeFd, UID_ROOT, g_pid);
1323 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1324 deviceTags, sessionFirst);
1325 handlerType = InputHandlerType::MONITOR;
1326 eventType = 0;
1327 priority = 2;
1328 deviceTags = 0;
1329 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1330 g_writeFd, UID_ROOT, g_pid);
1331 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1332 deviceTags, sessionSecond);
1333 for (int32_t i = 0; i < MAX_N_INPUT_INTERCEPTORS; i++) {
1334 interceptorHandler.interceptors_.push_back(interceptorSecond);
1335 }
1336 int32_t result = interceptorHandler.AddInterceptor(interceptorFirst);
1337 EXPECT_EQ(result, RET_ERR);
1338 ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
1339 }
1340
1341 /**
1342 * @tc.name: EventInterceptorHandler_AddInterceptor_07
1343 * @tc.desc: Test AddInterceptor
1344 * @tc.type: FUNC
1345 * @tc.require:
1346 */
1347 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_07, TestSize.Level1)
1348 {
1349 CALL_TEST_DEBUG;
1350 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1351 InputHandlerType handlerType = InputHandlerType::MONITOR;
1352 HandleEventType eventType = 0;
1353 int32_t priority = 1;
1354 uint32_t deviceTags = 0;
1355 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1356 g_writeFd, UID_ROOT, g_pid);
1357 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1358 deviceTags, sessionFirst);
1359 handlerType = InputHandlerType::MONITOR;
1360 eventType = 0;
1361 priority = 2;
1362 deviceTags = 0;
1363 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1364 g_writeFd, UID_ROOT, g_pid);
1365 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1366 deviceTags, sessionSecond);
1367 for (int32_t i = 0; i < MAX_N_INPUT_INTERCEPTORS - 1; i++) {
1368 interceptorHandler.interceptors_.push_back(interceptorSecond);
1369 }
1370 EXPECT_EQ(interceptorHandler.AddInterceptor(interceptorFirst), RET_OK);
1371 int32_t result = interceptorHandler.AddInterceptor(interceptorFirst);
1372 EXPECT_EQ(result, RET_OK);
1373 uint32_t num = interceptorHandler.interceptors_.size();
1374 EXPECT_EQ(num, 16);
1375 ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
1376 }
1377
1378 /**
1379 * @tc.name: EventInterceptorHandler_AddInterceptor_08
1380 * @tc.desc: Test AddInterceptor
1381 * @tc.type: FUNC
1382 * @tc.require:
1383 */
1384 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_08, TestSize.Level1)
1385 {
1386 CALL_TEST_DEBUG;
1387 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1388 InputHandlerType handlerType = InputHandlerType::MONITOR;
1389 HandleEventType eventType = 0;
1390 int32_t priority = 1;
1391 uint32_t deviceTags = 11;
1392 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1393 g_writeFd, UID_ROOT, g_pid);
1394 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1395 deviceTags, sessionFirst);
1396 interceptorHandler.interceptors_.push_back(interceptorFirst);
1397 handlerType = InputHandlerType::INTERCEPTOR;
1398 eventType = 5;
1399 priority = 2;
1400 deviceTags = 0;
1401 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1402 g_writeFd, UID_ROOT, g_pid);
1403 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1404 deviceTags, sessionSecond);
1405 interceptorHandler.interceptors_.push_back(interceptorSecond);
1406 int32_t result = interceptorHandler.AddInterceptor(interceptorSecond);
1407 EXPECT_EQ(result, RET_OK);
1408 uint32_t num = interceptorHandler.interceptors_.size();
1409 EXPECT_EQ(num, 2);
1410 ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorSecond));
1411 }
1412
1413 /**
1414 * @tc.name: EventInterceptorHandler_AddInterceptor_09
1415 * @tc.desc: Test AddInterceptor
1416 * @tc.type: FUNC
1417 * @tc.require:
1418 */
1419 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_09, TestSize.Level1)
1420 {
1421 CALL_TEST_DEBUG;
1422 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1423 InputHandlerType handlerType = InputHandlerType::MONITOR;
1424 HandleEventType eventType = 5;
1425 int32_t priority = 1;
1426 uint32_t deviceTags = 0;
1427 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1428 g_writeFd, UID_ROOT, g_pid);
1429 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1430 deviceTags, sessionFirst);
1431 interceptorHandler.interceptors_.push_back(interceptorFirst);
1432 handlerType = InputHandlerType::NONE;
1433 eventType = 5;
1434 priority = 2;
1435 deviceTags = 0;
1436 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1437 g_writeFd, UID_ROOT, g_pid);
1438 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1439 deviceTags, sessionSecond);
1440 int32_t result = interceptorHandler.AddInterceptor(interceptorSecond);
1441 EXPECT_EQ(result, RET_OK);
1442 uint32_t num = interceptorHandler.interceptors_.size();
1443 EXPECT_EQ(num, 2);
1444 ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
1445 }
1446
1447 /**
1448 * @tc.name: EventInterceptorHandler_AddInterceptor_10
1449 * @tc.desc: Test AddInterceptor
1450 * @tc.type: FUNC
1451 * @tc.require:
1452 */
1453 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_10, TestSize.Level1)
1454 {
1455 CALL_TEST_DEBUG;
1456 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1457 InputHandlerType handlerType = InputHandlerType::MONITOR;
1458 HandleEventType eventType = 5;
1459 int32_t priority = 1;
1460 uint32_t deviceTags = 0;
1461 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1462 g_writeFd, UID_ROOT, g_pid);
1463 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1464 deviceTags, sessionFirst);
1465 int32_t result = interceptorHandler.AddInterceptor(interceptorFirst);
1466 EXPECT_EQ(result, RET_OK);
1467 uint32_t num = interceptorHandler.interceptors_.size();
1468 EXPECT_EQ(num, 1);
1469 ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
1470 }
1471
1472 /**
1473 * @tc.name: EventInterceptorHandler_AddInterceptor_11
1474 * @tc.desc: Test AddInterceptor
1475 * @tc.type: FUNC
1476 * @tc.require:
1477 */
1478 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_11, TestSize.Level1)
1479 {
1480 CALL_TEST_DEBUG;
1481 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1482 InputHandlerType handlerType = InputHandlerType::MONITOR;
1483 HandleEventType eventType = 5;
1484 int32_t priority = 1;
1485 uint32_t deviceTags = 0;
1486 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1487 g_writeFd, UID_ROOT, g_pid);
1488 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1489 deviceTags, sessionFirst);
1490 for (int32_t i = 0; i < MAX_N_INPUT_INTERCEPTORS; i++) {
1491 interceptorHandler.interceptors_.push_back(interceptorFirst);
1492 }
1493 int32_t result = interceptorHandler.AddInterceptor(interceptorFirst);
1494 EXPECT_EQ(result, RET_OK);
1495 uint32_t num = interceptorHandler.interceptors_.size();
1496 EXPECT_EQ(num, MAX_N_INPUT_INTERCEPTORS);
1497 }
1498
1499 /**
1500 * @tc.name: EventInterceptorHandler_AddInterceptor_12
1501 * @tc.desc: Test AddInterceptor
1502 * @tc.type: FUNC
1503 * @tc.require:
1504 */
1505 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_12, TestSize.Level1)
1506 {
1507 CALL_TEST_DEBUG;
1508 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1509 InputHandlerType handlerType = InputHandlerType::MONITOR;
1510 HandleEventType eventType = 5;
1511 int32_t priority = 20;
1512 uint32_t deviceTags = 0;
1513 const std::string programName = "uds_session_test";
1514 const int32_t moduleType = 1;
1515 const int32_t writeFd = 1;
1516 const int32_t uid = 2;
1517 const int32_t pid = 10;
1518 SessionPtr sessionFirst = std::make_shared<UDSSession>(programName, moduleType,
1519 writeFd, uid, pid);
1520 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1521 deviceTags, sessionFirst);
1522 interceptorHandler.interceptors_.push_back(interceptorFirst);
1523 EXPECT_EQ(interceptorHandler.interceptors_.front().priority_, 20);
1524 int32_t result = interceptorHandler.AddInterceptor(interceptorFirst);
1525 EXPECT_EQ(result, RET_OK);
1526 uint32_t num = interceptorHandler.interceptors_.size();
1527 EXPECT_EQ(num, 1);
1528 ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorFirst));
1529 }
1530
1531 /**
1532 * @tc.name: EventInterceptorHandler_AddInterceptor_13
1533 * @tc.desc: Test AddInterceptor
1534 * @tc.type: FUNC
1535 * @tc.require:
1536 */
1537 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_13, TestSize.Level1)
1538 {
1539 CALL_TEST_DEBUG;
1540 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1541 InputHandlerType handlerType = InputHandlerType::MONITOR;
1542 HandleEventType eventType = 5;
1543 int32_t priority = 20;
1544 uint32_t deviceTags = 0;
1545 const std::string programName = "uds_session_test";
1546 const int32_t moduleType = 1;
1547 const int32_t writeFd = 1;
1548 const int32_t uid = 2;
1549 const int32_t pid = 10;
1550 SessionPtr sessionFirst = std::make_shared<UDSSession>(programName, moduleType,
1551 writeFd, uid, pid);
1552 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1553 deviceTags, sessionFirst);
1554 interceptorHandler.interceptors_.push_back(interceptorFirst);
1555 priority = 30;
1556 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1557 deviceTags, sessionFirst);
1558 interceptorHandler.interceptors_.push_back(interceptorSecond);
1559 priority = 40;
1560 EventInterceptorHandler::SessionHandler interceptorThird(handlerType, eventType, priority,
1561 deviceTags, sessionFirst);
1562 interceptorHandler.interceptors_.push_back(interceptorThird);
1563 EXPECT_EQ(interceptorHandler.interceptors_.back().priority_, 40);
1564 int32_t result = interceptorHandler.AddInterceptor(interceptorThird);
1565 EXPECT_EQ(result, RET_OK);
1566 uint32_t num = interceptorHandler.interceptors_.size();
1567 EXPECT_EQ(num, 3);
1568 ASSERT_NO_FATAL_FAILURE(interceptorHandler.AddInterceptor(interceptorThird));
1569 }
1570
1571 /**
1572 * @tc.name: EventInterceptorHandler_AddInterceptor_14
1573 * @tc.desc: Test AddInterceptor
1574 * @tc.type: FUNC
1575 * @tc.require:
1576 */
1577 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_AddInterceptor_14, TestSize.Level1)
1578 {
1579 CALL_TEST_DEBUG;
1580 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1581 InputHandlerType handlerType = InputHandlerType::MONITOR;
1582 HandleEventType eventType = 5;
1583 int32_t priority = 20;
1584 uint32_t deviceTags = 0;
1585 const std::string programName = "uds_session_test";
1586 const int32_t moduleType = 1;
1587 const int32_t writeFd = 1;
1588 const int32_t uid = 2;
1589 int32_t pid = 10;
1590 SessionPtr sessionFirst = std::make_shared<UDSSession>(programName, moduleType,
1591 writeFd, uid, pid);
1592 pid = 20;
1593 SessionPtr sessionSecond = std::make_shared<UDSSession>(programName, moduleType,
1594 writeFd, uid, pid);
1595 pid = 30;
1596 SessionPtr sessionThird = std::make_shared<UDSSession>(programName, moduleType,
1597 writeFd, uid, pid);
1598 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1599 deviceTags, sessionFirst);
1600 interceptorHandler.interceptors_.push_back(interceptorFirst);
1601 priority = 30;
1602 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1603 deviceTags, sessionSecond);
1604 interceptorHandler.interceptors_.push_back(interceptorSecond);
1605 priority = 40;
1606 EventInterceptorHandler::SessionHandler interceptorThird(handlerType, eventType, priority,
1607 deviceTags, sessionThird);
1608 interceptorHandler.interceptors_.push_back(interceptorThird);
1609 EXPECT_EQ(interceptorHandler.interceptors_.back().priority_, 40);
1610 int32_t result = interceptorHandler.AddInterceptor(interceptorThird);
1611 EXPECT_EQ(result, RET_OK);
1612 uint32_t num = interceptorHandler.interceptors_.size();
1613 EXPECT_EQ(num, 3);
1614 }
1615
1616 /**
1617 * @tc.name: EventInterceptorHandler_RemoveInterceptor_05
1618 * @tc.desc: Test RemoveInterceptor
1619 * @tc.type: FUNC
1620 * @tc.require:
1621 */
1622 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_05, TestSize.Level1)
1623 {
1624 CALL_TEST_DEBUG;
1625 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1626 InputHandlerType handlerType = InputHandlerType::INTERCEPTOR;
1627 HandleEventType eventType = 0;
1628 int32_t priority = 0;
1629 uint32_t deviceTags = 0;
1630 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1631 g_writeFd, UID_ROOT, g_pid);
1632 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1633 deviceTags, sessionFirst);
1634 interceptorHandler.interceptors_.push_back(interceptorFirst);
1635 handlerType = InputHandlerType::INTERCEPTOR;
1636 eventType = 0;
1637 priority = 0;
1638 deviceTags = 0;
1639 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1640 g_writeFd, UID_ROOT, g_pid);
1641 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1642 deviceTags, sessionSecond);
1643 interceptorHandler.interceptors_.push_back(interceptorSecond);
1644 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
1645 EXPECT_FALSE(interceptorHandler.interceptors_.empty());
1646 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorSecond));
1647 EXPECT_TRUE(interceptorHandler.interceptors_.empty());
1648 }
1649
1650 /**
1651 * @tc.name: EventInterceptorHandler_RemoveInterceptor_06
1652 * @tc.desc: Test RemoveInterceptor
1653 * @tc.type: FUNC
1654 * @tc.require:
1655 */
1656 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_06, TestSize.Level1)
1657 {
1658 CALL_TEST_DEBUG;
1659 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1660 InputHandlerType handlerType = InputHandlerType::INTERCEPTOR;
1661 HandleEventType eventType = 0;
1662 int32_t priority = 0;
1663 uint32_t deviceTags = 0;
1664 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1665 g_writeFd, UID_ROOT, g_pid);
1666 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1667 deviceTags, sessionFirst);
1668 interceptorHandler.interceptors_.push_back(interceptorFirst);
1669 interceptorHandler.RemoveInterceptor(interceptorFirst);
1670 EXPECT_TRUE(interceptorHandler.interceptors_.empty());
1671 }
1672
1673 /**
1674 * @tc.name: EventInterceptorHandler_RemoveInterceptor_07
1675 * @tc.desc: Test RemoveInterceptor
1676 * @tc.type: FUNC
1677 * @tc.require:
1678 */
1679 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_07, TestSize.Level1)
1680 {
1681 CALL_TEST_DEBUG;
1682 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1683 InputHandlerType handlerType = InputHandlerType::INTERCEPTOR;
1684 HandleEventType eventType = 1;
1685 int32_t priority = 1;
1686 uint32_t deviceTags = 0;
1687 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1688 g_writeFd, UID_ROOT, g_pid);
1689 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1690 deviceTags, sessionFirst);
1691 handlerType = InputHandlerType::INTERCEPTOR;
1692 eventType = 1;
1693 priority = 2;
1694 deviceTags = 0;
1695 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1696 g_writeFd, UID_ROOT, g_pid);
1697 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1698 deviceTags, sessionSecond);
1699 interceptorHandler.interceptors_.push_back(interceptorSecond);
1700 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
1701 interceptorHandler.RemoveInterceptor(interceptorSecond);
1702 EXPECT_FALSE(interceptorHandler.interceptors_.empty());
1703 }
1704
1705 /**
1706 * @tc.name: EventInterceptorHandler_RemoveInterceptor_08
1707 * @tc.desc: Test RemoveInterceptor
1708 * @tc.type: FUNC
1709 * @tc.require:
1710 */
1711 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_08, TestSize.Level1)
1712 {
1713 CALL_TEST_DEBUG;
1714 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1715 InputHandlerType handlerType = InputHandlerType::INTERCEPTOR;
1716 HandleEventType eventType = 1;
1717 int32_t priority = 1;
1718 uint32_t deviceTags = 0;
1719 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1720 g_writeFd, UID_ROOT, g_pid);
1721 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1722 deviceTags, sessionFirst);
1723 interceptorHandler.interceptors_.push_back(interceptorFirst);
1724 handlerType = InputHandlerType::INTERCEPTOR;
1725 eventType = 1;
1726 priority = 0;
1727 deviceTags = 0;
1728 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1729 g_writeFd, UID_ROOT, g_pid);
1730 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1731 deviceTags, sessionSecond);
1732 interceptorHandler.interceptors_.push_back(interceptorSecond);
1733 interceptorHandler.RemoveInterceptor(interceptorFirst);
1734 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
1735 EXPECT_FALSE(interceptorHandler.interceptors_.empty());
1736 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorSecond));
1737 interceptorHandler.RemoveInterceptor(interceptorSecond);
1738 EXPECT_FALSE(interceptorHandler.interceptors_.empty());
1739 }
1740
1741 /**
1742 * @tc.name: EventInterceptorHandler_RemoveInterceptor_09
1743 * @tc.desc: Test RemoveInterceptor
1744 * @tc.type: FUNC
1745 * @tc.require:
1746 */
1747 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_09, TestSize.Level1)
1748 {
1749 CALL_TEST_DEBUG;
1750 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1751 InputHandlerType handlerType = InputHandlerType::MONITOR;
1752 HandleEventType eventType = 0;
1753 int32_t priority = 0;
1754 uint32_t deviceTags = 0;
1755 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1756 g_writeFd, UID_ROOT, g_pid);
1757 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1758 deviceTags, sessionFirst);
1759 handlerType = InputHandlerType::MONITOR;
1760 eventType = 0;
1761 priority = 0;
1762 deviceTags = 0;
1763 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1764 g_writeFd, UID_ROOT, g_pid);
1765 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1766 deviceTags, sessionSecond);
1767 interceptorHandler.interceptors_.push_back(interceptorSecond);
1768 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorSecond));
1769 EXPECT_TRUE(interceptorHandler.interceptors_.empty());
1770 }
1771
1772 /**
1773 * @tc.name: EventInterceptorHandler_RemoveInterceptor_10
1774 * @tc.desc: Test RemoveInterceptor
1775 * @tc.type: FUNC
1776 * @tc.require:
1777 */
1778 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_10, TestSize.Level1)
1779 {
1780 CALL_TEST_DEBUG;
1781 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1782 InputHandlerType handlerType = InputHandlerType::MONITOR;
1783 HandleEventType eventType = 0;
1784 int32_t priority = 0;
1785 uint32_t deviceTags = 0;
1786 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1787 g_writeFd, UID_ROOT, g_pid);
1788 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1789 deviceTags, sessionFirst);
1790 interceptorHandler.interceptors_.push_back(interceptorFirst);
1791 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
1792 interceptorHandler.RemoveInterceptor(interceptorFirst);
1793 EXPECT_TRUE(interceptorHandler.interceptors_.empty());
1794 }
1795
1796 /**
1797 * @tc.name: EventInterceptorHandler_RemoveInterceptor_11
1798 * @tc.desc: Test RemoveInterceptor
1799 * @tc.type: FUNC
1800 * @tc.require:
1801 */
1802 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_11, TestSize.Level1)
1803 {
1804 CALL_TEST_DEBUG;
1805 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1806 InputHandlerType handlerType = InputHandlerType::MONITOR;
1807 HandleEventType eventType = 1;
1808 int32_t priority = 1;
1809 uint32_t deviceTags = 0;
1810 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1811 g_writeFd, UID_ROOT, g_pid);
1812 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1813 deviceTags, sessionFirst);
1814 interceptorHandler.interceptors_.push_back(interceptorFirst);
1815 handlerType = InputHandlerType::MONITOR;
1816 eventType = 1;
1817 priority = 20;
1818 deviceTags = 0;
1819 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1820 g_writeFd, UID_ROOT, g_pid);
1821 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1822 deviceTags, sessionSecond);
1823 interceptorHandler.interceptors_.push_back(interceptorSecond);
1824 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
1825 interceptorHandler.RemoveInterceptor(interceptorSecond);
1826 EXPECT_FALSE(interceptorHandler.interceptors_.empty());
1827 }
1828
1829 /**
1830 * @tc.name: EventInterceptorHandler_RemoveInterceptor_12
1831 * @tc.desc: Test RemoveInterceptor
1832 * @tc.type: FUNC
1833 * @tc.require:
1834 */
1835 HWTEST_F(EventInterceptorHandlerTest, EventInterceptorHandler_RemoveInterceptor_12, TestSize.Level1)
1836 {
1837 CALL_TEST_DEBUG;
1838 EventInterceptorHandler::InterceptorCollection interceptorHandler;
1839 InputHandlerType handlerType = InputHandlerType::MONITOR;
1840 HandleEventType eventType = 5;
1841 int32_t priority = 1;
1842 uint32_t deviceTags = 0;
1843 SessionPtr sessionFirst = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1844 g_writeFd, UID_ROOT, g_pid);
1845 EventInterceptorHandler::SessionHandler interceptorFirst(handlerType, eventType, priority,
1846 deviceTags, sessionFirst);
1847 handlerType = InputHandlerType::MONITOR;
1848 eventType = 5;
1849 priority = 10;
1850 deviceTags = 0;
1851 SessionPtr sessionSecond = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType,
1852 g_writeFd, UID_ROOT, g_pid);
1853 EventInterceptorHandler::SessionHandler interceptorSecond(handlerType, eventType, priority,
1854 deviceTags, sessionSecond);
1855 interceptorHandler.interceptors_.push_back(interceptorSecond);
1856 ASSERT_NO_FATAL_FAILURE(interceptorHandler.RemoveInterceptor(interceptorFirst));
1857 interceptorHandler.RemoveInterceptor(interceptorSecond);
1858 EXPECT_FALSE(interceptorHandler.interceptors_.empty());
1859 }
1860 } // namespace MMI
1861 } // namespace OH