1 /*
2  * Copyright (c) 2023 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 "event_util_test.h"
17 #include "input_manager_util.h"
18 #include "multimodal_event_handler.h"
19 
20 #undef MMI_LOG_TAG
21 #define MMI_LOG_TAG "InputManagerSimulateTest"
22 
23 namespace OHOS {
24 namespace MMI {
25 namespace {
26 constexpr int32_t TIME_WAIT_FOR_OP = 100;
27 constexpr int32_t NANOSECOND_TO_MILLISECOND = 1000000;
28 constexpr int32_t DEFAULT_POINTER_ID = 0;
29 constexpr int32_t DEFAULT_DEVICE_ID = 0;
30 constexpr int32_t POINTER_ID = -1;
31 constexpr int32_t INPUT_INTERCEPTOR_ONE = 2;
32 constexpr int32_t INPUT_INTERCEPTOR_TWO = 3;
33 constexpr int32_t INTERCEPTOR_PRIORITY_ONE = 400;
34 constexpr int32_t INTERCEPTOR_PRIORITY_TWO = 500;
35 constexpr int32_t INTERCEPTOR_PRIORITY_THREE = 600;
36 constexpr int32_t POINTER_ITEM_DISPLAY_X_ONE = 90;
37 constexpr int32_t POINTER_ITEM_DISPLAY_X_THREE = 123;
38 constexpr int32_t POINTER_ITEM_DISPLAY_X_FIVE = 222;
39 constexpr int32_t POINTER_ITEM_DISPLAY_X_EIGHT = 505;
40 constexpr int32_t POINTER_ITEM_DISPLAY_X_NINE = 523;
41 constexpr int32_t POINTER_ITEM_DISPLAY_X_TEN = 528;
42 constexpr int32_t POINTER_ITEM_DISPLAY_X_ELEVEN = 543;
43 constexpr int32_t POINTER_ITEM_DISPLAY_X_THIRTEEN = 640;
44 constexpr int32_t POINTER_ITEM_DISPLAY_X_FOURTEEN = 660;
45 constexpr int32_t POINTER_ITEM_DISPLAY_X_SIXTEEN = 710;
46 constexpr int32_t POINTER_ITEM_DISPLAY_X_SEVENTEEN = 852;
47 constexpr int32_t POINTER_ITEM_DISPLAY_Y_THREE = 223;
48 constexpr int32_t POINTER_ITEM_DISPLAY_Y_FOUR = 357;
49 constexpr int32_t POINTER_ITEM_DISPLAY_Y_FIVE = 367;
50 constexpr int32_t POINTER_ITEM_DISPLAY_Y_EIGHT = 505;
51 constexpr int32_t POINTER_ITEM_DISPLAY_Y_TEN = 666;
52 constexpr int32_t POINTER_ITEM_DISPLAY_Y_ELEVEN = 723;
53 constexpr int32_t POINTER_ITEM_DISPLAY_Y_TWELVE = 757;
54 constexpr int32_t POINTER_ITEM_DISPLAY_Y_THIRTEEN = 840;
55 constexpr int32_t POINTER_ITEM_DISPLAY_Y_FOURTEEN = 860;
56 constexpr int32_t POINTER_ITEM_DISPLAY_Y_FIFTEEN = 863;
57 constexpr int32_t POINTER_ITEM_DISPLAY_Y_SIXTEEN = 910;
58 constexpr int32_t POINTER_ITEM_DOWN_TIME_TWO = 10005;
59 constexpr int32_t POINTER_ITEM_DOWN_TIME_THREE = 10006;
60 constexpr int32_t POINTER_ITEM_DOWN_TIME_FOUR = 10007;
61 constexpr double POINTER_ITEM_PRESSURE_ONE = 5.0;
62 constexpr double POINTER_ITEM_PRESSURE_TWO = 7.0;
63 }  // namespace
64 
65 class InputManagerSimulateTest : public testing::Test {
66 public:
67     void SetUp();
68     void TearDown();
69     static void SetUpTestCase();
70     std::string GetEventDump();
71 };
72 
SetUpTestCase()73 void InputManagerSimulateTest::SetUpTestCase()
74 {
75     ASSERT_TRUE(TestUtil->Init());
76 }
77 
SetUp()78 void InputManagerSimulateTest::SetUp()
79 {
80     TestUtil->SetRecvFlag(RECV_FLAG::RECV_FOCUS);
81 }
82 
TearDown()83 void InputManagerSimulateTest::TearDown()
84 {
85     TestUtil->AddEventDump("");
86     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
87 }
88 
GetEventDump()89 std::string InputManagerSimulateTest::GetEventDump()
90 {
91     return TestUtil->GetEventDump();
92 }
93 
94 /**
95  * @tc.name: MultimodalEventHandler_SimulateKeyEvent_004
96  * @tc.desc: Verify simulate key exception event
97  * @tc.type: FUNC
98  * @tc.require:
99  */
100 HWTEST_F(InputManagerSimulateTest, InputManagerSimulateTest_SimulateKeyEvent_004, TestSize.Level1)
101 {
102     CALL_TEST_DEBUG;
103     std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
104     ASSERT_TRUE(injectDownEvent != nullptr);
105     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
106     KeyEvent::KeyItem kitDown;
107     kitDown.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
108     kitDown.SetPressed(true);
109     kitDown.SetDownTime(downTime);
110     injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
111     injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
112     injectDownEvent->AddPressedKeyItems(kitDown);
113 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
114     TestSimulateInputEvent(injectDownEvent, TestScene::EXCEPTION_TEST);
115 #endif  // OHOS_BUILD_ENABLE_KEYBOARD
116 }
117 
118 /**
119  * @tc.name: MultimodalEventHandler_SimulatePointerEvent_004
120  * @tc.desc: Verify simulate screen exception event
121  * @tc.type: FUNC
122  * @tc.require:
123  */
124 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_004, TestSize.Level1)
125 {
126     CALL_TEST_DEBUG;
127     auto pointerEvent = PointerEvent::Create();
128     ASSERT_TRUE(pointerEvent != nullptr);
129     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
130     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
131     pointerEvent->SetPointerId(POINTER_ID);
132 #ifdef OHOS_BUILD_ENABLE_TOUCH
133     TestSimulateInputEvent(pointerEvent, TestScene::EXCEPTION_TEST);
134 #endif  // OHOS_BUILD_ENABLE_TOUCH
135 }
136 
137 /**
138  * @tc.name: MultimodalEventHandler_SimulatePointerEvent_008
139  * @tc.desc: Verify simulate mouse exception event
140  * @tc.type: FUNC
141  * @tc.require:
142  */
143 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_008, TestSize.Level1)
144 {
145     CALL_TEST_DEBUG;
146     auto pointerEvent = PointerEvent::Create();
147     ASSERT_TRUE(pointerEvent != nullptr);
148     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
149     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
150     pointerEvent->SetPointerId(POINTER_ID);
151 #ifdef OHOS_BUILD_ENABLE_POINTER
152     TestSimulateInputEvent(pointerEvent, TestScene::EXCEPTION_TEST);
153 #endif  // OHOS_BUILD_ENABLE_POINTER
154 }
155 
156 /**
157  * @tc.name: InputManager_Pencil2InputEvent_004
158  * @tc.desc: Verify simulate exception event
159  * @tc.type: FUNC
160  * @tc.require:
161  */
162 HWTEST_F(InputManagerSimulateTest, InputManager_Pencil2InputEvent_004, TestSize.Level1)
163 {
164     CALL_TEST_DEBUG;
165     auto pointerEvent = PointerEvent::Create();
166     ASSERT_TRUE(pointerEvent != nullptr);
167     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
168     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
169     pointerEvent->SetPointerId(POINTER_ID);
170 #ifdef OHOS_BUILD_ENABLE_TOUCH
171     TestSimulateInputEvent(pointerEvent, TestScene::EXCEPTION_TEST);
172 #endif  // OHOS_BUILD_ENABLE_TOUCH
173 }
174 
175 /**
176  * @tc.name: TestInputEventInterceptor_006
177  * @tc.desc: Verify touchscreen interceptor
178  * @tc.type: FUNC
179  * @tc.require:
180  */
181 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_006, TestSize.Level1)
182 {
183     CALL_TEST_DEBUG;
184     auto pointerEvent = PointerEvent::Create();
185     pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
186     ASSERT_TRUE(pointerEvent != nullptr);
187     PointerEvent::PointerItem item;
188     item.SetPointerId(0);
189     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_FIVE);
190     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_FOUR);
191     item.SetPressure(POINTER_ITEM_PRESSURE_ONE);
192     item.SetDeviceId(1);
193     pointerEvent->AddPointerItem(item);
194     item.SetPointerId(1);
195     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_SIXTEEN);
196     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_SIXTEEN);
197     item.SetPressure(POINTER_ITEM_PRESSURE_TWO);
198     item.SetDeviceId(1);
199     pointerEvent->AddPointerItem(item);
200     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
201     pointerEvent->SetPointerId(1);
202     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
203 
204     auto interceptor = GetPtr<InputEventCallback>();
205     int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
206 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
207     EXPECT_TRUE(IsValidHandlerId(interceptorId));
208 #else
209     EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
210 #endif  // OHOS_BUILD_ENABLE_INTERCEPTOR
211     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
212 
213     if (IsValidHandlerId(interceptorId)) {
214         InputManager::GetInstance()->RemoveInterceptor(interceptorId);
215         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
216     }
217 }
218 
219 /**
220  * @tc.name: TestInputEventInterceptor_008
221  * @tc.desc: Verify touchscreen interceptor
222  * @tc.type: FUNC
223  * @tc.require:
224  */
225 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_008, TestSize.Level1)
226 {
227     CALL_TEST_DEBUG;
228     TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
229     auto pointerEvent = PointerEvent::Create();
230     ASSERT_NE(pointerEvent, nullptr);
231     PointerEvent::PointerItem item;
232     item.SetDownTime(POINTER_ITEM_DOWN_TIME_FOUR);
233     item.SetPointerId(0);
234     item.SetDeviceId(1);
235     item.SetPressed(true);
236     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_TEN);
237     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_TWELVE);
238     pointerEvent->SetPointerId(0);
239     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
240     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
241     pointerEvent->AddPointerItem(item);
242 
243     auto interceptor = GetPtr<InputEventCallback>();
244     int32_t interceptorId = InputManager::GetInstance()->AddInterceptor(interceptor);
245 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
246     EXPECT_TRUE(IsValidHandlerId(interceptorId));
247 #else
248     EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
249 #endif  // OHOS_BUILD_ENABLE_INTERCEPTOR
250     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
251 
252     InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
253 
254     std::string sPointerEs = GetEventDump();
255     MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
256 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_INIERCEPTOR)
257     ASSERT_TRUE(!sPointerEs.empty());
258 #else
259     ASSERT_FALSE(sPointerEs.empty());
260 #endif // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_INIERCEPTOR
261     if (IsValidHandlerId(interceptorId)) {
262         InputManager::GetInstance()->RemoveInterceptor(interceptorId);
263         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
264     }
265 }
266 
267 /**
268  * @tc.name: TestInputEventInterceptor_009
269  * @tc.desc: Verify mouse interceptor
270  * @tc.type: FUNC
271  * @tc.require:
272  */
273 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_009, TestSize.Level1)
274 {
275     CALL_TEST_DEBUG;
276     TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
277     auto pointerEvent = PointerEvent::Create();
278     ASSERT_NE(pointerEvent, nullptr);
279     PointerEvent::PointerItem item;
280     item.SetPointerId(0);
281     item.SetDownTime(POINTER_ITEM_DOWN_TIME_THREE);
282     item.SetPressed(true);
283     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_ELEVEN);
284     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_FIFTEEN);
285     item.SetDeviceId(1);
286     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
287     pointerEvent->AddPointerItem(item);
288     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
289     pointerEvent->SetPointerId(0);
290 
291     auto interceptor = GetPtr<InputEventCallback>();
292     int32_t interceptorId = InputManager::GetInstance()->AddInterceptor(interceptor);
293 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
294     EXPECT_TRUE(IsValidHandlerId(interceptorId));
295 #else
296     EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
297 #endif  // OHOS_BUILD_ENABLE_INTERCEPTOR
298     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
299 
300     InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
301 
302     std::string sPointerEs = GetEventDump();
303     MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
304 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_INIERCEPTOR)
305     ASSERT_TRUE(!sPointerEs.empty());
306 #else
307     ASSERT_FALSE(sPointerEs.empty());
308 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_INIERCEPTOR
309     if (IsValidHandlerId(interceptorId)) {
310         InputManager::GetInstance()->RemoveInterceptor(interceptorId);
311         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
312     }
313 }
314 
315 /**
316  * @tc.name: TestInputEventInterceptor_010
317  * @tc.desc: Verify volume key interceptor
318  * @tc.type: FUNC
319  * @tc.require:
320  */
321 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_010, TestSize.Level1)
322 {
323     CALL_TEST_DEBUG;
324     TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
325     std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
326     ASSERT_NE(injectDownEvent, nullptr);
327     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
328     KeyEvent::KeyItem kitDown;
329     kitDown.SetDownTime(downTime);
330     kitDown.SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
331     kitDown.SetPressed(true);
332     kitDown.SetDeviceId(1);
333     injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
334     injectDownEvent->AddPressedKeyItems(kitDown);
335     injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
336 
337     auto interceptor = GetPtr<InputEventCallback>();
338     int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
339 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
340     EXPECT_TRUE(IsValidHandlerId(interceptorId));
341 #else
342     EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
343 #endif  // OHOS_BUILD_ENABLE_INTERCEPTOR
344     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
345 
346     InputManager::GetInstance()->SimulateInputEvent(injectDownEvent);
347 
348     std::string sPointerEs = GetEventDump();
349     MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
350     if (IsValidHandlerId(interceptorId)) {
351         InputManager::GetInstance()->RemoveInterceptor(interceptorId);
352         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
353     }
354 }
355 
356 /**
357  * @tc.name: TestInputEventInterceptor_012
358  * @tc.desc: Verify mouse interceptor
359  * @tc.type: FUNC
360  * @tc.require:
361  */
362 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_012, TestSize.Level1)
363 {
364     CALL_TEST_DEBUG;
365     TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
366     auto pointerEvent = PointerEvent::Create();
367     ASSERT_NE(pointerEvent, nullptr);
368     PointerEvent::PointerItem item;
369     item.SetPointerId(0);
370     item.SetDownTime(POINTER_ITEM_DOWN_TIME_TWO);
371     item.SetPressed(true);
372     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_SEVENTEEN);
373     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_FIVE);
374     item.SetDeviceId(1);
375     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
376     pointerEvent->SetPointerId(0);
377     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
378     pointerEvent->AddPointerItem(item);
379 
380     auto interceptor = GetPtr<InputEventCallback>();
381     uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX);
382     int32_t interceptorId =
383         InputManager::GetInstance()->AddInterceptor(interceptor, INTERCEPTOR_PRIORITY_ONE, touchTags);
384 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
385     EXPECT_TRUE(IsValidHandlerId(interceptorId));
386 #else
387     EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
388 #endif  // OHOS_BUILD_ENABLE_INTERCEPTOR
389     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
390 
391     InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
392 
393     std::string sPointerEs = GetEventDump();
394     MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
395 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_INIERCEPTOR)
396     ASSERT_TRUE(!sPointerEs.empty());
397 #else
398     ASSERT_FALSE(sPointerEs.empty());
399 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_INIERCEPTOR
400     if (IsValidHandlerId(interceptorId)) {
401         InputManager::GetInstance()->RemoveInterceptor(interceptorId);
402         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
403     }
404 }
405 
406 /**
407  * @tc.name: TestInputEventInterceptor_014
408  * @tc.desc: Verify space key interceptor
409  * @tc.type: FUNC
410  * @tc.require:
411  */
412 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_014, TestSize.Level1)
413 {
414     CALL_TEST_DEBUG;
415     TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
416     std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
417     ASSERT_NE(injectDownEvent, nullptr);
418     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
419     KeyEvent::KeyItem kitDown;
420     kitDown.SetDeviceId(1);
421     kitDown.SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
422     kitDown.SetPressed(true);
423     kitDown.SetDownTime(downTime);
424     injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
425     injectDownEvent->AddPressedKeyItems(kitDown);
426     injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
427 
428     auto interceptor2 = GetPtr<PriorityMiddleCallback>();
429     auto interceptor1 = GetPtr<PriorityHighCallback>();
430     uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX);
431     int32_t interceptorId2{
432         InputManager::GetInstance()->AddInterceptor(interceptor2, INTERCEPTOR_PRIORITY_TWO, touchTags)};
433     int32_t interceptorId1{
434         InputManager::GetInstance()->AddInterceptor(interceptor1, INTERCEPTOR_PRIORITY_ONE, touchTags)};
435 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
436     EXPECT_TRUE(IsValidHandlerId(interceptorId1));
437     EXPECT_TRUE(IsValidHandlerId(interceptorId2));
438 #else
439     EXPECT_EQ(interceptorId1, ERROR_UNSUPPORT);
440     EXPECT_EQ(interceptorId2, ERROR_UNSUPPORT);
441 #endif  // OHOS_BUILD_ENABLE_INTERCEPTOR
442     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
443 
444     InputManager::GetInstance()->SimulateInputEvent(injectDownEvent);
445     for (size_t i = 0; i < INPUT_INTERCEPTOR_ONE; ++i) {
446         std::string sPointerEs = GetEventDump();
447         MMI_HILOGD("PriorityLevel Test:sPointerEs:%{public}s", sPointerEs.c_str());
448 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
449         if (i == 0) {
450             EXPECT_NE(sPointerEs, "Call high interceptors");
451         } else {
452             ASSERT_TRUE(sPointerEs.empty());
453         }
454 #else
455         ASSERT_TRUE(sPointerEs.empty());
456 #endif  // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR
457     }
458 
459     InputManagerUtil::TestInterceptorId(interceptorId1, interceptorId2);
460 }
461 
462 /**
463  * @tc.name: TestInputEventInterceptor_015
464  * @tc.desc: Verify space key interceptor
465  * @tc.type: FUNC
466  * @tc.require:
467  */
468 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_015, TestSize.Level1)
469 {
470     CALL_TEST_DEBUG;
471     TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
472     std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
473     ASSERT_NE(injectDownEvent, nullptr);
474     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
475     KeyEvent::KeyItem kitDown;
476     kitDown.SetPressed(true);
477     kitDown.SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
478     kitDown.SetDeviceId(1);
479     kitDown.SetDownTime(downTime);
480     injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
481     injectDownEvent->AddPressedKeyItems(kitDown);
482     injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
483 
484     uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX);
485     int32_t interceptorId1{InputManager::GetInstance()->AddInterceptor(
486         GetPtr<PriorityHighCallback>(), INTERCEPTOR_PRIORITY_TWO, touchTags)};
487     int32_t interceptorId2{InputManager::GetInstance()->AddInterceptor(
488         GetPtr<PriorityMiddleCallback>(), INTERCEPTOR_PRIORITY_THREE, touchTags)};
489 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
490     EXPECT_TRUE(IsValidHandlerId(interceptorId1));
491     EXPECT_TRUE(IsValidHandlerId(interceptorId2));
492 #else
493     EXPECT_EQ(interceptorId1, ERROR_UNSUPPORT);
494     EXPECT_EQ(interceptorId2, ERROR_UNSUPPORT);
495 #endif  // OHOS_BUILD_ENABLE_INTERCEPTOR
496     if (IsValidHandlerId(interceptorId1)) {
497         InputManager::GetInstance()->RemoveInterceptor(interceptorId1);
498         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
499     }
500 
501     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
502     InputManager::GetInstance()->SimulateInputEvent(injectDownEvent);
503     for (size_t i = 0; i < INPUT_INTERCEPTOR_TWO; ++i) {
504         std::string sPointerEs = GetEventDump();
505         MMI_HILOGD("PriorityLevel Test:sPointerEs:%{public}s", sPointerEs.c_str());
506 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
507         if (i == 0) {
508             EXPECT_NE(sPointerEs, "Call middle interceptors");
509         } else {
510             ASSERT_TRUE(sPointerEs.empty());
511         }
512 #else
513         ASSERT_TRUE(sPointerEs.empty());
514 #endif  // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR
515     }
516 
517     if (IsValidHandlerId(interceptorId2)) {
518         InputManager::GetInstance()->RemoveInterceptor(interceptorId2);
519         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
520     }
521 }
522 
523 /**
524  * @tc.name: TestInputEventInterceptor_016
525  * @tc.desc: Verify keyevent interceptor
526  * @tc.type: FUNC
527  * @tc.require:
528  */
529 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_016, TestSize.Level1)
530 {
531     CALL_TEST_DEBUG;
__anonf4ae3cce0202(std::shared_ptr<KeyEvent> keyEvent) 532     auto fun = [](std::shared_ptr<KeyEvent> keyEvent) { MMI_HILOGD("Add interceptor success"); };
533     int32_t interceptorId = InputManager::GetInstance()->AddInterceptor(fun);
534 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
535     ASSERT_NE(interceptorId, INVALID_HANDLER_ID);
536 #else
537     ASSERT_EQ(interceptorId, ERROR_UNSUPPORT);
538 #endif  // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR
539     if (IsValidHandlerId(interceptorId)) {
540         InputManager::GetInstance()->RemoveInterceptor(interceptorId);
541     }
542 }
543 
544 /**
545  * @tc.name: InputManager_TouchPadSimulateInputEvent_001
546  * @tc.desc: Verify touchpad simulate and monitor
547  * @tc.type: FUNC
548  * @tc.require:
549  */
550 HWTEST_F(InputManagerSimulateTest, InputManager_TouchPadSimulateInputEvent_001, TestSize.Level1)
551 {
552     CALL_TEST_DEBUG;
553     auto callbackPtr = GetPtr<InputEventCallback>();
554     ASSERT_NE(callbackPtr, nullptr);
555     int32_t monitorId{InputManagerUtil::TestAddMonitor(callbackPtr)};
556 #ifdef OHOS_BUILD_ENABLE_MONITOR
557     EXPECT_TRUE(monitorId >= MIN_HANDLER_ID);
558 #else
559     EXPECT_EQ(monitorId, ERROR_UNSUPPORT);
560 #endif  // OHOS_BUILD_ENABLE_MONITOR
561     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
562 
563     int64_t stepTime = GetSysClockTime();
564     auto pointerEvent = PointerEvent::Create();
565     ASSERT_TRUE(pointerEvent != nullptr);
566     PointerEvent::PointerItem item{};
567     item.SetPointerId(DEFAULT_POINTER_ID);
568     item.SetDownTime(stepTime);
569     item.SetPressed(true);
570     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_NINE);
571     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_ELEVEN);
572     item.SetDeviceId(DEFAULT_DEVICE_ID);
573     pointerEvent->AddPointerItem(item);
574     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
575     pointerEvent->SetActionTime(stepTime);
576     pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
577     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
578 }
579 
580 /**
581  * @tc.name: InputManager_TouchPadSimulateInputEvent_002
582  * @tc.desc: Verify touchpad simulate and monitor
583  * @tc.type: FUNC
584  * @tc.require:
585  */
586 HWTEST_F(InputManagerSimulateTest, InputManager_TouchPadSimulateInputEvent_002, TestSize.Level1)
587 {
588     CALL_TEST_DEBUG;
589     auto callbackPtr = GetPtr<InputEventCallback>();
590     ASSERT_NE(callbackPtr, nullptr);
591     int32_t monitorId{InputManagerUtil::TestAddMonitor(callbackPtr)};
592 #ifdef OHOS_BUILD_ENABLE_MONITOR
593     EXPECT_TRUE(monitorId >= MIN_HANDLER_ID);
594 #else
595     EXPECT_EQ(monitorId, ERROR_UNSUPPORT);
596 #endif  // OHOS_BUILD_ENABLE_MONITOR
597     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
598 
599     int64_t measureTime = GetSysClockTime();
600     auto pointerEvent = PointerEvent::Create();
601     ASSERT_TRUE(pointerEvent != nullptr);
602     PointerEvent::PointerItem item{};
603     item.SetPointerId(DEFAULT_POINTER_ID);
604     item.SetDownTime(measureTime);
605     item.SetPressed(true);
606     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_ONE);
607     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_TEN);
608     item.SetDeviceId(DEFAULT_DEVICE_ID);
609     pointerEvent->AddPointerItem(item);
610     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
611     pointerEvent->SetActionTime(measureTime);
612     pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
613     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
614 }
615 
616 /**
617  * @tc.name: InputManager_TouchPadSimulateInputEvent_003
618  * @tc.desc: Verify touchpad simulate and monitor
619  * @tc.type: FUNC
620  * @tc.require:
621  */
622 HWTEST_F(InputManagerSimulateTest, InputManager_TouchPadSimulateInputEvent_003, TestSize.Level1)
623 {
624     CALL_TEST_DEBUG;
625     auto callbackPtr = GetPtr<InputEventCallback>();
626     ASSERT_NE(callbackPtr, nullptr);
627     int32_t monitorId{InputManagerUtil::TestAddMonitor(callbackPtr)};
628 #ifdef OHOS_BUILD_ENABLE_MONITOR
629     EXPECT_TRUE(monitorId >= MIN_HANDLER_ID);
630 #else
631     EXPECT_EQ(monitorId, ERROR_UNSUPPORT);
632 #endif  // OHOS_BUILD_ENABLE_MONITOR
633     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
634 
635     int64_t deedTime = GetSysClockTime();
636     auto pointerEvent = PointerEvent::Create();
637     ASSERT_TRUE(pointerEvent != nullptr);
638     PointerEvent::PointerItem item{};
639     item.SetPointerId(DEFAULT_POINTER_ID);
640     item.SetDownTime(deedTime);
641     item.SetPressed(false);
642     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_EIGHT);
643     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_EIGHT);
644     item.SetDeviceId(DEFAULT_DEVICE_ID);
645     pointerEvent->AddPointerItem(item);
646     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
647     pointerEvent->SetActionTime(deedTime);
648     pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
649     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
650 }
651 
652 /**
653  * @tc.name: InputManager_TouchPadSimulateInputEvent_004
654  * @tc.desc: Verify touchpad simulate and monitor
655  * @tc.type: FUNC
656  * @tc.require:
657  */
658 HWTEST_F(InputManagerSimulateTest, InputManager_TouchPadSimulateInputEvent_004, TestSize.Level1)
659 {
660     CALL_TEST_DEBUG;
661     auto callbackPtr = GetPtr<InputEventCallback>();
662     ASSERT_NE(callbackPtr, nullptr);
663     int32_t monitorId{InputManagerUtil::TestAddMonitor(callbackPtr)};
664 #ifdef OHOS_BUILD_ENABLE_MONITOR
665     EXPECT_TRUE(monitorId >= MIN_HANDLER_ID);
666 #else
667     EXPECT_EQ(monitorId, ERROR_UNSUPPORT);
668 #endif  // OHOS_BUILD_ENABLE_MONITOR
669     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
670 
671     int64_t actionTime = GetSysClockTime();
672     auto pointerEvent = PointerEvent::Create();
673     ASSERT_TRUE(pointerEvent != nullptr);
674     PointerEvent::PointerItem item{};
675     item.SetPointerId(DEFAULT_POINTER_ID);
676     item.SetDownTime(actionTime);
677     item.SetPressed(true);
678     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_THREE);
679     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_THREE);
680     item.SetDeviceId(DEFAULT_DEVICE_ID);
681     pointerEvent->AddPointerItem(item);
682     item.SetPointerId(1);
683     item.SetDownTime(actionTime);
684     item.SetPressed(true);
685     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_THIRTEEN);
686     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_THIRTEEN);
687     item.SetDeviceId(DEFAULT_DEVICE_ID);
688     pointerEvent->AddPointerItem(item);
689     item.SetPointerId(2);
690     item.SetDownTime(actionTime);
691     item.SetPressed(true);
692     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_FOURTEEN);
693     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_FOURTEEN);
694     item.SetDeviceId(DEFAULT_DEVICE_ID);
695     pointerEvent->AddPointerItem(item);
696     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
697     pointerEvent->SetActionTime(actionTime);
698     pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
699     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
700 }
701 }  // namespace MMI
702 }  // namespace OHOS