1 /*
2  * Copyright (C) 2022 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 <gtest/gtest.h>
17 #include "accessibility_common_helper.h"
18 #include "accessibility_input_interceptor.h"
19 #include "accessibility_ut_helper.h"
20 #include "accessible_ability_manager_service.h"
21 #include "iservice_registry.h"
22 #include "mock_accessible_ability_manager_service.h"
23 #include "mock_bundle_manager.h"
24 #include "mock_input_manager.h"
25 
26 using namespace testing;
27 using namespace testing::ext;
28 
29 namespace OHOS {
30 namespace Accessibility {
31 namespace {
32     constexpr uint32_t SLEEP_TIME_3 = 3;
33 } // namespace
34 
35 class AccessibilityInputInterceptorTest : public testing::Test {
36 public:
AccessibilityInputInterceptorTest()37     AccessibilityInputInterceptorTest()
38     {}
~AccessibilityInputInterceptorTest()39     ~AccessibilityInputInterceptorTest()
40     {}
41 
42     static void SetUpTestCase();
43     static void TearDownTestCase();
44     void SetUp() override;
45     void TearDown() override;
46 
47     sptr<AccessibilityInputInterceptor> inputInterceptor_ = nullptr;
48 };
49 
SetUpTestCase()50 void AccessibilityInputInterceptorTest::SetUpTestCase()
51 {
52     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest SetUpTestCase";
53     Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
54 }
55 
TearDownTestCase()56 void AccessibilityInputInterceptorTest::TearDownTestCase()
57 {
58     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest TearDownTestCase";
59     Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
60 }
61 
SetUp()62 void AccessibilityInputInterceptorTest::SetUp()
63 {
64     MMI::MockInputManager::ClearInputEventConsumer();
65     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest SetUp";
66     inputInterceptor_ = AccessibilityInputInterceptor::GetInstance();
67 }
68 
TearDown()69 void AccessibilityInputInterceptorTest::TearDown()
70 {
71     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest TearDown";
72     inputInterceptor_ = nullptr;
73 }
74 
75 /**
76  * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001
77  * @tc.name: SetAvailableFunctions
78  * @tc.desc: Check the set available Functions.
79  */
80 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001,
81     TestSize.Level1)
82 {
83     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001 start";
84 
85     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_FILTER_KEY_EVENTS;
86     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001 94";
87     inputInterceptor_->SetAvailableFunctions(availableFunctions);
88 
89     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001 end";
90 }
91 
92 /**
93  * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions002
94  * @tc.name: SetAvailableFunctions
95  * @tc.desc: Check the set available Functions.
96  */
97 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions002,
98     TestSize.Level1)
99 {
100     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions002 start";
101 
102     uint32_t availableFunctions2 = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
103     inputInterceptor_->SetAvailableFunctions(availableFunctions2);
104 
105     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions002 end";
106 }
107 
108 /**
109  * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions003
110  * @tc.name: SetAvailableFunctions
111  * @tc.desc: Check the set available Functions.
112  */
113 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions003,
114     TestSize.Level1)
115 {
116     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions003 start";
117 
118     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_TOUCH_EXPLORATION;
119 
120     inputInterceptor_->SetAvailableFunctions(availableFunctions);
121 
122     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions003 end";
123 }
124 
125 /**
126  * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions004
127  * @tc.name: SetAvailableFunctions
128  * @tc.desc: Check the set available Functions.
129  */
130 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions004,
131     TestSize.Level1)
132 {
133     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions004 start";
134     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_SCREEN_MAGNIFICATION;
135     inputInterceptor_->SetAvailableFunctions(availableFunctions);
136 
137     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions004 end";
138 }
139 
140 /**
141  * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions005
142  * @tc.name: SetAvailableFunctions
143  * @tc.desc: Check the set available Functions.
144  */
145 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions005,
146     TestSize.Level1)
147 {
148     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions005 start";
149     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_SCREEN_MAGNIFICATION |
150         AccessibilityInputInterceptor::FEATURE_MOUSE_AUTOCLICK |
151         AccessibilityInputInterceptor::FEATURE_MOUSE_KEY;
152     inputInterceptor_->SetAvailableFunctions(availableFunctions);
153 
154     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions005 end";
155 }
156 
157 /**
158  * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions006
159  * @tc.name: SetAvailableFunctions
160  * @tc.desc: Check the set available Functions.
161  */
162 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions006,
163     TestSize.Level1)
164 {
165     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions006 start";
166     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_MOUSE_AUTOCLICK;
167     inputInterceptor_->SetAvailableFunctions(availableFunctions);
168     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions006 end";
169 }
170 
171 /**
172  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001
173  * @tc.name: OnTouchEvent
174  * @tc.desc: Check the on touch event.
175  */
176 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001, TestSize.Level1)
177 {
178     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001 start";
179 
180     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
181     inputInterceptor_->OnPointerEvent(*event);
182 
183     EXPECT_NE(event.get(), nullptr);
184     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001 end";
185 }
186 
187 /**
188  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002
189  * @tc.name: InterceptPointerEventCallBack
190  * @tc.desc: Check the on touch event.
191  */
192 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002, TestSize.Level1)
193 {
194     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002 start";
195     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
196     inputInterceptor_->SetAvailableFunctions(availableFunctions);
197 
198     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
199     MMI::PointerEvent::PointerItem item = {};
200 
201     item.SetPointerId(1);
202     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
203     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
204     event->AddPointerItem(item);
205 
206     auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
207     if (inputEventConsumer != nullptr) {
208         inputEventConsumer->OnInputEvent(event);
209     }
210     /* wait ProcessTouchEvent */
211     sleep(SLEEP_TIME_3);
212     EXPECT_NE(event.get(), nullptr);
213     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002 end";
214 }
215 
216 /**
217  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003
218  * @tc.name: InterceptPointerEventCallBack
219  * @tc.desc: Check the on touch event.
220  */
221 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003, TestSize.Level1)
222 {
223     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003 start";
224     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
225     inputInterceptor_->SetAvailableFunctions(availableFunctions);
226 
227     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
228     MMI::PointerEvent::PointerItem item = {};
229 
230     item.SetPointerId(1);
231     item.SetDisplayX(1);
232     item.SetDisplayY(1);
233     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
234     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
235     event->AddPointerItem(item);
236 
237     auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
238     if (inputEventConsumer != nullptr) {
239         inputEventConsumer->OnInputEvent(event);
240     }
241     /* wait ProcessTouchEvent */
242     sleep(SLEEP_TIME_3);
243 
244     EXPECT_NE(event.get(), nullptr);
245     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003 end";
246 }
247 
248 /**
249  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1
250  * @tc.name: OnMouseEvent
251  * @tc.desc: Check the on mouse event.
252  */
253 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1, TestSize.Level1)
254 {
255     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1 start";
256 
257     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
258     MMI::PointerEvent::PointerItem item = {};
259 
260     item.SetPointerId(1);
261     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
262     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
263     event->AddPointerItem(item);
264 
265     EXPECT_NE(event.get(), nullptr);
266     inputInterceptor_->OnPointerEvent(*event);
267     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1 end";
268 }
269 
270 /**
271  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002
272  * @tc.name: InterceptPointerEventCallBack
273  * @tc.desc: Check the on mouse event.
274  */
275 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002, TestSize.Level1)
276 {
277     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002 start";
278     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
279     inputInterceptor_->SetAvailableFunctions(availableFunctions);
280 
281     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
282     MMI::PointerEvent::PointerItem item = {};
283 
284     item.SetPointerId(1);
285     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
286     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
287     event->AddPointerItem(item);
288 
289     auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
290     if (inputEventConsumer != nullptr) {
291         inputEventConsumer->OnInputEvent(event);
292     }
293     /* wait ProcessMouseEvent */
294     sleep(SLEEP_TIME_3);
295     EXPECT_NE(event.get(), nullptr);
296     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002 end";
297 }
298 
299 /**
300  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003
301  * @tc.name: OnInputEvent
302  * @tc.desc: Check the on mouse event.
303  */
304 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003, TestSize.Level1)
305 {
306     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003 start";
307     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_TOUCH_EXPLORATION;
308     inputInterceptor_->SetAvailableFunctions(availableFunctions);
309 
310     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
311     MMI::PointerEvent::PointerItem item = {};
312 
313     item.SetPointerId(1);
314     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
315     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
316     event->AddPointerItem(item);
317 
318     auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
319     if (inputEventConsumer != nullptr) {
320         inputEventConsumer->OnInputEvent(event);
321     }
322     /* wait ProcessMouseEvent */
323     sleep(SLEEP_TIME_3);
324     EXPECT_NE(event.get(), nullptr);
325     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003 end";
326 }
327 
328 /**
329  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001
330  * @tc.name: OnKeyEvent
331  * @tc.desc: Check the on key event.
332  */
333 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001, TestSize.Level1)
334 {
335     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001 start";
336 
337     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
338     inputInterceptor_->OnKeyEvent(*event);
339     EXPECT_NE(event.get(), nullptr);
340     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001 end";
341 }
342 
343 /**
344  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002
345  * @tc.name: OnInputEvent
346  * @tc.desc: Check the on key event.
347  */
348 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002, TestSize.Level1)
349 {
350     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002 start";
351 
352     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
353     MMI::KeyEvent::KeyItem item = {};
354 
355     item.SetPressed(true);
356     keyEvent->AddKeyItem(item);
357     keyEvent->SetKeyCode(1);
358 
359     auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
360     if (inputEventConsumer != nullptr) {
361         inputEventConsumer->OnInputEvent(keyEvent);
362     }
363 
364     /* wait ProcessKeyEvent */
365     sleep(SLEEP_TIME_3);
366     EXPECT_NE(keyEvent.get(), nullptr);
367     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002 end";
368 }
369 
370 /**
371  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003
372  * @tc.name: OnKeyEvent
373  * @tc.desc: Check the on key event.
374  */
375 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003, TestSize.Level1)
376 {
377     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003 start";
378     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_FILTER_KEY_EVENTS;
379     inputInterceptor_->SetAvailableFunctions(availableFunctions);
380 
381     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
382     MMI::KeyEvent::KeyItem item = {};
383 
384     item.SetPressed(true);
385     keyEvent->AddKeyItem(item);
386     keyEvent->SetKeyCode(1);
387 
388     /* wait ProcessKeyEvent */
389     sleep(SLEEP_TIME_3);
390     EXPECT_NE(keyEvent.get(), nullptr);
391     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003 end";
392 }
393 
394 /**
395  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001
396  * @tc.name: OnMoveMouse
397  * @tc.desc: Check the OnMoveMouse.
398  */
399 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001,
400     TestSize.Level1)
401 {
402     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001 start";
403     if (!inputInterceptor_) {
404         return;
405     }
406     inputInterceptor_->OnMoveMouse(1, 1);
407 
408     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001 end";
409 }
410 
411 /**
412  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnInputEvent001
413  * @tc.name: OnInputEvent
414  * @tc.desc: Check the OnInputEvent.
415  */
416 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnInputEvent001,
417     TestSize.Level1)
418 {
419     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnInputEvent001 start";
420     if (!inputInterceptor_) {
421         return;
422     }
423     std::shared_ptr<MMI::KeyEvent> keyEvent = nullptr;
424     std::shared_ptr<AccessibilityInputEventConsumer> inputEventConsumer_ =
425         std::make_shared<AccessibilityInputEventConsumer>();
426     inputEventConsumer_->OnInputEvent(keyEvent);
427 
428     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnInputEvent001 end";
429 }
430 
431 /**
432  * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnInputEvent002
433  * @tc.name: OnInputEvent
434  * @tc.desc: Check the OnInputEvent.
435  */
436 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnInputEvent002,
437     TestSize.Level1)
438 {
439     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnInputEvent002 start";
440     if (!inputInterceptor_) {
441         return;
442     }
443     std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
444     std::shared_ptr<AccessibilityInputEventConsumer> inputEventConsumer_ =
445         std::make_shared<AccessibilityInputEventConsumer>();
446     inputEventConsumer_->OnInputEvent(pointerEvent);
447 
448     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnInputEvent002 end";
449 }
450 
451 /**
452  * @tc.number: AccessibilityInputInterceptorTest_Unittest_ProcessPointerEvent001
453  * @tc.name: ProcessPointerEvent
454  * @tc.desc: Check the ProcessPointerEvent.
455  */
456 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_ProcessPointerEvent001,
457     TestSize.Level1)
458 {
459     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_ProcessPointerEvent001 start";
460     uint32_t availableFunctions = 0;
461     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
462     inputInterceptor_->SetAvailableFunctions(availableFunctions);
463     inputInterceptor_->ProcessPointerEvent(event);
464     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_ProcessPointerEvent001 end";
465 }
466 
467 /**
468  * @tc.number: AccessibilityInputInterceptorTest_Unittest_ProcessKeyEvent001
469  * @tc.name: ProcessKeyEvent
470  * @tc.desc: Check the ProcessKeyEvent.
471  */
472 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_ProcessKeyEvent001,
473     TestSize.Level1)
474 {
475     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_ProcessKeyEvent001 start";
476     uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_MOUSE_AUTOCLICK;
477     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
478     inputInterceptor_->SetAvailableFunctions(availableFunctions);
479     inputInterceptor_->ProcessKeyEvent(event);
480     GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_ProcessKeyEvent001 end";
481 }
482 } // namespace Accessibility
483 } // namespace OHOS