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 <memory>
17 #include <gtest/gtest.h>
18 
19 #include "event_filter_handler.h"
20 #include "event_normalize_handler.h"
21 #include "event_filter_service.h"
22 #include "i_input_event_handler.h"
23 #include "mmi_log.h"
24 #include "util.h"
25 
26 #undef MMI_LOG_TAG
27 #define MMI_LOG_TAG "EventFilterHandlerTest"
28 namespace OHOS {
29 namespace MMI {
30 namespace {
31 using namespace testing::ext;
32 } // namespace
33 
34 class EventFilterHandlerTest : public testing::Test {
35 public:
SetUpTestCase(void)36     static void SetUpTestCase(void) {}
TearDownTestCase(void)37     static void TearDownTestCase(void) {}
38 
SetUp()39     void SetUp() {}
TearDown()40     void TearDown() {}
41 };
42 
43 class MyEventFilter : public IRemoteStub<IEventFilter> {
44 public:
HandleKeyEvent(const std::shared_ptr<KeyEvent> event)45     bool HandleKeyEvent(const std::shared_ptr<KeyEvent> event) override
46     {
47         return true;
48     }
HandlePointerEvent(const std::shared_ptr<PointerEvent> event)49     bool HandlePointerEvent(const std::shared_ptr<PointerEvent> event) override
50     {
51         return true;
52     }
53 };
54 
55 /**
56  * @tc.name: EventFilterHandlerTest_HandleKeyEvent_001
57  * @tc.desc: Verify the HandleKeyEvent and HandleKeyEventFilter
58  * @tc.type: FUNC
59  * @tc.require:
60  */
61 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_KeyEvent_001, TestSize.Level1)
62 {
63     CALL_TEST_DEBUG;
64     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
65     EXPECT_NE(keyEvent, nullptr);
66     EventFilterHandler event;
67     bool flag = event.HandleKeyEventFilter(keyEvent);
68     EXPECT_FALSE(flag);
69     EventNormalizeHandler eventNormal;
70     auto nextHandler = std::make_shared<EventNormalizeHandler>();
71     eventNormal.SetNext(nextHandler);
72     eventNormal.HandleKeyEvent(keyEvent);
73 }
74 
75 /**
76  * @tc.name: EventFilterHandlerTest_Dump_001
77  * @tc.desc: Verify the Dump
78  * @tc.type: FUNC
79  * @tc.require:
80  */
81 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_Dump_001, TestSize.Level1)
82 {
83     CALL_TEST_DEBUG;
84     EventFilterHandler event;
85     int32_t fd = 0;
86     std::vector<std::string> args = {};
87     std::vector<std::string> idNames = {};
88     event.Dump(fd, args);
89     ASSERT_EQ(args, idNames);
90 }
91 
92 /**
93  * @tc.name: EventFilterHandlerTest_AddInputEventFilter_001
94  * @tc.desc: Verify the AddInputEventFilter
95  * @tc.type: FUNC
96  * @tc.require:
97  */
98 
99 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_AddInputEventFilter_001, TestSize.Level1)
100 {
101     CALL_TEST_DEBUG;
102     auto event = std::make_shared<EventFilterHandler>();
103     EXPECT_NE(event, nullptr);
104     sptr<IEventFilter> filter = new (std::nothrow) MyEventFilter();
105     EXPECT_NE(filter, nullptr);
106     int32_t filterId = 200;
107     int32_t priority = 201;
108     uint32_t deviceTags = 3;
109     int32_t clientPid = 3;
110     int32_t ret = event->AddInputEventFilter(filter, filterId, priority, deviceTags, clientPid);
111     EXPECT_EQ(ret, RET_OK);
112 
113     filterId = 2;
114     priority = 5;
115     ret = event->AddInputEventFilter(filter, filterId, priority, deviceTags, clientPid);
116     EXPECT_EQ(ret, RET_OK);
117 }
118 
119 /**
120  * @tc.name: EventFilterHandlerTest_RemoveInputEventFilter_001
121  * @tc.desc: Verify the RemoveInputEventFilter
122  * @tc.type: FUNC
123  * @tc.require:
124  */
125 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_RemoveInputEventFilter_001, TestSize.Level1)
126 {
127     CALL_TEST_DEBUG;
128     auto event = std::make_shared<EventFilterHandler>();
129     EXPECT_NE(event, nullptr);
130     sptr<IEventFilter> filter = new (std::nothrow) MyEventFilter();
131     EXPECT_NE(filter, nullptr);
132     int32_t filterId = -1;
133     int32_t clientPid = 12345;
134     int32_t result = event->RemoveInputEventFilter(filterId, clientPid);
135     EXPECT_EQ(result, RET_OK);
136 
137     uint32_t deviceTags = 0;
138     int32_t ret = event->AddInputEventFilter(filter, 10, 6, deviceTags, clientPid);
139     EXPECT_EQ(ret, RET_OK);
140     ret = event->AddInputEventFilter(filter, 1, 5, deviceTags, clientPid);
141     EXPECT_EQ(ret, RET_OK);
142     result = event->RemoveInputEventFilter(-1, clientPid);
143     EXPECT_EQ(result, RET_OK);
144     result = event->RemoveInputEventFilter(1, clientPid);
145     EXPECT_EQ(result, RET_OK);
146     result = event->RemoveInputEventFilter(2, clientPid);
147     EXPECT_EQ(result, RET_OK);
148 }
149 
150 /**
151  * @tc.name: EventFilterHandlerTest_HandleKeyEventFilter_001
152  * @tc.desc: Verify the HandleKeyEventFilter
153  * @tc.type: FUNC
154  * @tc.require:
155  */
156 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandleKeyEventFilter_001, TestSize.Level1)
157 {
158     CALL_TEST_DEBUG;
159     auto event = std::make_shared<EventFilterHandler>();
160     EXPECT_NE(event, nullptr);
161     sptr<IEventFilter> filter = new (std::nothrow) MyEventFilter();
162     EXPECT_NE(filter, nullptr);
163     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
164     EXPECT_NE(keyEvent, nullptr);
165     bool flag = event->HandleKeyEventFilter(keyEvent);
166     EXPECT_FALSE(flag);
167 
168     int32_t filterId = 1;
169     int32_t priority = 10;
170     uint32_t deviceTags = 0;
171     int32_t clientPid = 0;
172     int32_t ret = event->AddInputEventFilter(filter, filterId, priority, deviceTags, clientPid);
173     EXPECT_EQ(ret, RET_OK);
174     flag = event->HandleKeyEventFilter(keyEvent);
175     EXPECT_FALSE(flag);
176 
177     KeyEvent::KeyItem item;
178     item.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
179     keyEvent->AddKeyItem(item);
180 
181     flag = event->HandleKeyEventFilter(keyEvent);
182     EXPECT_FALSE(flag);
183 }
184 
185 /**
186  * @tc.name: EventFilterHandlerTest_HandlePointerEventFilter_001
187  * @tc.desc: Verify the HandlePointerEventFilter
188  * @tc.type: FUNC
189  * @tc.require:
190  */
191 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandlePointerEventFilter_001, TestSize.Level1)
192 {
193     CALL_TEST_DEBUG;
194     auto event = std::make_shared<EventFilterHandler>();
195     EXPECT_NE(event, nullptr);
196     sptr<IEventFilter> filter = new (std::nothrow) MyEventFilter();
197     EXPECT_NE(filter, nullptr);
198     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
199     EXPECT_NE(pointerEvent, nullptr);
200     bool flag = event->HandlePointerEventFilter(pointerEvent);
201     EXPECT_FALSE(flag);
202 
203     int32_t filterId = 1;
204     int32_t priority = 10;
205     uint32_t deviceTags = 0;
206     int32_t clientPid = 0;
207     int32_t ret = event->AddInputEventFilter(filter, filterId, priority, deviceTags, clientPid);
208     EXPECT_EQ(ret, RET_OK);
209 
210     flag = event->HandlePointerEventFilter(pointerEvent);
211     EXPECT_FALSE(flag);
212 
213     PointerEvent::PointerItem item;
214     item.SetPointerId(1);
215     item.SetDisplayX(1);
216     item.SetDisplayY(1);
217     pointerEvent->AddPointerItem(item);
218 
219     flag = event->HandlePointerEventFilter(pointerEvent);
220     EXPECT_FALSE(flag);
221 }
222 
223 /**
224  * @tc.name: EventFilterHandlerTest_HandleKeyEvent_002
225  * @tc.desc: Verify the HandleKeyEvent
226  * @tc.type: FUNC
227  * @tc.require:
228  */
229 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandleKeyEvent_002, TestSize.Level1)
230 {
231     CALL_TEST_DEBUG;
232     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
233     EXPECT_NE(keyEvent, nullptr);
234     EventFilterHandler event;
235     KeyEvent::KeyItem item;
236     item.SetDeviceId(1);
237     keyEvent->AddKeyItem(item);
238     bool result = event.HandleKeyEventFilter(keyEvent);
239     ASSERT_FALSE(result);
240     ASSERT_NO_FATAL_FAILURE(event.HandleKeyEvent(keyEvent));
241 }
242 
243 /**
244  * @tc.name: EventFilterHandlerTest_HandlePointerEvent_001
245  * @tc.desc: Verify the HandlePointerEvent
246  * @tc.type: FUNC
247  * @tc.require:
248  */
249 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandlePointerEvent_001, TestSize.Level1)
250 {
251     CALL_TEST_DEBUG;
252     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
253     EXPECT_NE(pointerEvent, nullptr);
254     EventFilterHandler event;
255     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
256     EXPECT_NE(keyEvent, nullptr);
257     KeyEvent::KeyItem item;
258     item.SetDeviceId(1);
259     keyEvent->AddKeyItem(item);
260     bool result = event.HandlePointerEventFilter(pointerEvent);
261     ASSERT_FALSE(result);
262     ASSERT_NO_FATAL_FAILURE(event.HandlePointerEvent(pointerEvent));
263 }
264 
265 /**
266  * @tc.name: EventFilterHandlerTest_HandleTouchEvent_001
267  * @tc.desc: Verify the HandleTouchEvent
268  * @tc.type: FUNC
269  * @tc.require:
270  */
271 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandleTouchEvent_001, TestSize.Level1)
272 {
273     CALL_TEST_DEBUG;
274     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
275     EXPECT_NE(pointerEvent, nullptr);
276     EventFilterHandler event;
277     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
278     EXPECT_NE(keyEvent, nullptr);
279     KeyEvent::KeyItem item;
280     item.SetDeviceId(1);
281     keyEvent->AddKeyItem(item);
282     bool result = event.HandlePointerEventFilter(pointerEvent);
283     ASSERT_FALSE(result);
284     ASSERT_NO_FATAL_FAILURE(event.HandleTouchEvent(pointerEvent));
285 }
286 
287 /**
288  * @tc.name: EventFilterHandlerTest_HandlePointerEventFilter_002
289  * @tc.desc: Verify the HandlePointerEventFilter
290  * @tc.type: FUNC
291  * @tc.require:
292  */
293 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandlePointerEventFilter_002, TestSize.Level1)
294 {
295     CALL_TEST_DEBUG;
296     std::shared_ptr<PointerEvent> event = PointerEvent::Create();
297     EXPECT_NE(event, nullptr);
298     EventFilterHandler handler;
299     bool result = handler.HandlePointerEventFilter(event);
300     ASSERT_FALSE(result);
301 }
302 
303 /**
304  * @tc.name: EventFilterHandlerTest_HandlePointerEventFilter_003
305  * @tc.desc: Verify the HandlePointerEventFilter
306  * @tc.type: FUNC
307  * @tc.require:
308  */
309 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandlePointerEventFilter_003, TestSize.Level1)
310 {
311     CALL_TEST_DEBUG;
312     std::shared_ptr<PointerEvent> event = PointerEvent::Create();
313     EXPECT_NE(event, nullptr);
314     EventFilterHandler handler;
315     EventFilterHandler::FilterInfo filter1 = {nullptr, nullptr, 1, 10, 0x1, 100};
316     EventFilterHandler::FilterInfo filter2 = {nullptr, nullptr, 2, 20, 0x2, 200};
317     EventFilterHandler::FilterInfo filter3 = {nullptr, nullptr, 3, 30, 0x3, 300};
318     handler.filters_.push_back(filter1);
319     handler.filters_.push_back(filter2);
320     handler.filters_.push_back(filter3);
321     ASSERT_EQ(handler.filters_.size(), 3);
322     ASSERT_TRUE(handler.filters_.front().IsSameClient(1, 100));
323     ASSERT_TRUE(handler.filters_.back().IsSameClient(3, 300));
324     bool result = handler.HandlePointerEventFilter(event);
325     ASSERT_FALSE(result);
326 }
327 
328 /**
329  * @tc.name: EventFilterHandlerTest_HandlePointerEventFilter_004
330  * @tc.desc: Verify the HandlePointerEventFilter
331  * @tc.type: FUNC
332  * @tc.require:
333  */
334 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandlePointerEventFilter_004, TestSize.Level1)
335 {
336     CALL_TEST_DEBUG;
337     std::shared_ptr<PointerEvent> event = PointerEvent::Create();
338     EXPECT_NE(event, nullptr);
339     EventFilterHandler handler;
340     EventFilterHandler::FilterInfo filter1 = {nullptr, nullptr, 1, 10, 0x1, 100};
341     EventFilterHandler::FilterInfo filter2 = {nullptr, nullptr, 2, 20, 0x2, 200};
342     EventFilterHandler::FilterInfo filter3 = {nullptr, nullptr, 3, 30, 0x3, 300};
343     handler.filters_.push_back(filter1);
344     handler.filters_.push_back(filter2);
345     handler.filters_.push_back(filter3);
346     ASSERT_EQ(handler.filters_.size(), 3);
347     ASSERT_TRUE(handler.filters_.front().IsSameClient(1, 100));
348     ASSERT_TRUE(handler.filters_.back().IsSameClient(3, 300));
349     int32_t pointerId = 1;
350     PointerEvent::PointerItem item;
351     item.SetPointerId(pointerId);
352     event->AddPointerItem(item);
353     event->SetPointerId(1);
354     bool result = handler.HandlePointerEventFilter(event);
355     ASSERT_FALSE(result);
356 }
357 
358 /**
359  * @tc.name: EventFilterHandlerTest_HandleKeyEventFilter_002
360  * @tc.desc: Verify the HandleKeyEventFilter
361  * @tc.type: FUNC
362  * @tc.require:
363  */
364 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandleKeyEventFilter_002, TestSize.Level1)
365 {
366     CALL_TEST_DEBUG;
367     std::shared_ptr<KeyEvent> event = KeyEvent::Create();
368     EXPECT_NE(event, nullptr);
369     EventFilterHandler handler;
370     bool result = handler.HandleKeyEventFilter(event);
371     ASSERT_FALSE(result);
372 }
373 
374 /**
375  * @tc.name: EventFilterHandlerTest_HandleKeyEventFilter_003
376  * @tc.desc: Verify the HandleKeyEventFilter
377  * @tc.type: FUNC
378  * @tc.require:
379  */
380 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandleKeyEventFilter_003, TestSize.Level1)
381 {
382     CALL_TEST_DEBUG;
383     std::shared_ptr<KeyEvent> event = KeyEvent::Create();
384     EXPECT_NE(event, nullptr);
385     EventFilterHandler handler;
386     EventFilterHandler::FilterInfo filter1 = {nullptr, nullptr, 1, 10, 0x1, 100};
387     EventFilterHandler::FilterInfo filter2 = {nullptr, nullptr, 2, 20, 0x2, 200};
388     EventFilterHandler::FilterInfo filter3 = {nullptr, nullptr, 3, 30, 0x3, 300};
389     handler.filters_.push_back(filter1);
390     handler.filters_.push_back(filter2);
391     handler.filters_.push_back(filter3);
392     ASSERT_EQ(handler.filters_.size(), 3);
393     ASSERT_TRUE(handler.filters_.front().IsSameClient(1, 100));
394     ASSERT_TRUE(handler.filters_.back().IsSameClient(3, 300));
395     bool result = handler.HandleKeyEventFilter(event);
396     ASSERT_FALSE(result);
397 }
398 
399 /**
400  * @tc.name: EventFilterHandlerTest_HandleKeyEventFilter_004
401  * @tc.desc: Verify the HandleKeyEventFilter
402  * @tc.type: FUNC
403  * @tc.require:
404  */
405 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_HandleKeyEventFilter_004, TestSize.Level1)
406 {
407     CALL_TEST_DEBUG;
408     std::shared_ptr<KeyEvent> event = KeyEvent::Create();
409     EXPECT_NE(event, nullptr);
410     std::shared_ptr<PointerEvent> pointevent = PointerEvent::Create();
411     EXPECT_NE(pointevent, nullptr);
412     EventFilterHandler handler;
413     EventFilterHandler::FilterInfo filter1 = {nullptr, nullptr, 1, 10, 0x1, 100};
414     EventFilterHandler::FilterInfo filter2 = {nullptr, nullptr, 2, 20, 0x2, 200};
415     EventFilterHandler::FilterInfo filter3 = {nullptr, nullptr, 3, 30, 0x3, 300};
416     handler.filters_.push_back(filter1);
417     handler.filters_.push_back(filter2);
418     handler.filters_.push_back(filter3);
419     ASSERT_EQ(handler.filters_.size(), 3);
420     ASSERT_TRUE(handler.filters_.front().IsSameClient(1, 100));
421     ASSERT_TRUE(handler.filters_.back().IsSameClient(3, 300));
422     int32_t pointerId = 1;
423     PointerEvent::PointerItem item;
424     item.SetPointerId(pointerId);
425     pointevent->AddPointerItem(item);
426     pointevent->SetPointerId(1);
427     bool result = handler.HandleKeyEventFilter(event);
428     ASSERT_FALSE(result);
429 }
430 
431 /**
432  * @tc.name: EventFilterHandlerTest_RemoveInputEventFilter
433  * @tc.desc: Verify the RemoveInputEventFilter
434  * @tc.type: FUNC
435  * @tc.require:
436  */
437 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_RemoveInputEventFilter, TestSize.Level1)
438 {
439     CALL_TEST_DEBUG;
440     EventFilterHandler filterHandler;
441     EventFilterHandler::FilterInfo filterInfo = { nullptr, nullptr, 300, 200, 0x1, 610 };
442     int32_t filterId = 300;
443     int32_t clientPid = 610;
444     filterHandler.filters_.emplace_front(filterInfo);
445     EXPECT_EQ(filterHandler.RemoveInputEventFilter(filterId, clientPid), RET_OK);
446 }
447 
448 /**
449  * @tc.name: EventFilterHandlerTest_RemoveInputEventFilter_002
450  * @tc.desc: Verify the RemoveInputEventFilter
451  * @tc.type: FUNC
452  * @tc.require:
453  */
454 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_RemoveInputEventFilter_002, TestSize.Level1)
455 {
456     CALL_TEST_DEBUG;
457     EventFilterHandler filterHandler;
458     EventFilterHandler::FilterInfo filterInfo = { nullptr, nullptr, 500, 200, 0x1, 300 };
459     int32_t filterId = 300;
460     int32_t clientPid = 610;
461     filterHandler.filters_.emplace_front(filterInfo);
462     EXPECT_EQ(filterHandler.RemoveInputEventFilter(filterId, clientPid), RET_OK);
463 }
464 
465 /**
466  * @tc.name: EventFilterHandlerTest_RemoveInputEventFilter_003
467  * @tc.desc: Verify the RemoveInputEventFilter
468  * @tc.type: FUNC
469  * @tc.require:
470  */
471 HWTEST_F(EventFilterHandlerTest, EventFilterHandlerTest_RemoveInputEventFilter_003, TestSize.Level1)
472 {
473     CALL_TEST_DEBUG;
474     EventFilterHandler filterHandler;
475     EventFilterHandler::FilterInfo filterInfo = { nullptr, nullptr, 500, 200, 0x1, 300 };
476     int32_t filterId = -1;
477     int32_t clientPid = 600;
478     filterHandler.filters_.emplace_front(filterInfo);
479     EXPECT_EQ(filterHandler.RemoveInputEventFilter(filterId, clientPid), RET_OK);
480 }
481 } // namespace MMI
482 } // namespace OHOS