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 namespace OHOS {
21 namespace MMI {
22 namespace {
23 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, MMI_LOG_DOMAIN, "InputManagerSimulateTest"};
24 constexpr int32_t TIME_WAIT_FOR_OP = 100;
25 constexpr int32_t NANOSECOND_TO_MILLISECOND = 1000000;
26 constexpr int32_t DEFAULT_POINTER_ID = 0;
27 constexpr int32_t DEFAULT_DEVICE_ID = 0;
28 constexpr int32_t INVAID_VALUE = -1;
29 constexpr int32_t POINTER_ID = -1;
30 constexpr int32_t SIZE_TYPE_CASE = 3;
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_TWO = 111;
38 constexpr int32_t POINTER_ITEM_DISPLAY_X_THREE = 123;
39 constexpr int32_t POINTER_ITEM_DISPLAY_X_FOUR = 200;
40 constexpr int32_t POINTER_ITEM_DISPLAY_X_FIVE = 222;
41 constexpr int32_t POINTER_ITEM_DISPLAY_X_SIX = 400;
42 constexpr int32_t POINTER_ITEM_DISPLAY_X_SEVEN = 500;
43 constexpr int32_t POINTER_ITEM_DISPLAY_X_EIGHT = 505;
44 constexpr int32_t POINTER_ITEM_DISPLAY_X_NINE = 523;
45 constexpr int32_t POINTER_ITEM_DISPLAY_X_TEN = 528;
46 constexpr int32_t POINTER_ITEM_DISPLAY_X_ELEVEN = 543;
47 constexpr int32_t POINTER_ITEM_DISPLAY_X_TWELVE = 623;
48 constexpr int32_t POINTER_ITEM_DISPLAY_X_THIRTEEN = 640;
49 constexpr int32_t POINTER_ITEM_DISPLAY_X_FOURTEEN = 660;
50 constexpr int32_t POINTER_ITEM_DISPLAY_X_FIFTEEN = 700;
51 constexpr int32_t POINTER_ITEM_DISPLAY_X_SIXTEEN = 710;
52 constexpr int32_t POINTER_ITEM_DISPLAY_X_SEVENTEEN = 852;
53 constexpr int32_t POINTER_ITEM_DISPLAY_Y_ONE = 200;
54 constexpr int32_t POINTER_ITEM_DISPLAY_Y_TWO = 222;
55 constexpr int32_t POINTER_ITEM_DISPLAY_Y_THREE = 223;
56 constexpr int32_t POINTER_ITEM_DISPLAY_Y_FOUR = 357;
57 constexpr int32_t POINTER_ITEM_DISPLAY_Y_FIVE = 367;
58 constexpr int32_t POINTER_ITEM_DISPLAY_Y_SIX = 400;
59 constexpr int32_t POINTER_ITEM_DISPLAY_Y_SEVEN = 500;
60 constexpr int32_t POINTER_ITEM_DISPLAY_Y_EIGHT = 505;
61 constexpr int32_t POINTER_ITEM_DISPLAY_Y_NINE = 600;
62 constexpr int32_t POINTER_ITEM_DISPLAY_Y_TEN = 666;
63 constexpr int32_t POINTER_ITEM_DISPLAY_Y_ELEVEN = 723;
64 constexpr int32_t POINTER_ITEM_DISPLAY_Y_TWELVE = 757;
65 constexpr int32_t POINTER_ITEM_DISPLAY_Y_THIRTEEN = 840;
66 constexpr int32_t POINTER_ITEM_DISPLAY_Y_FOURTEEN = 860;
67 constexpr int32_t POINTER_ITEM_DISPLAY_Y_FIFTEEN = 863;
68 constexpr int32_t POINTER_ITEM_DISPLAY_Y_SIXTEEN = 910;
69 constexpr int32_t POINTER_ITEM_DISPLAY_Y_SEVENTEEN = 943;
70 constexpr int32_t POINTER_ITEM_DOWN_TIME_ONE = 10004;
71 constexpr int32_t POINTER_ITEM_DOWN_TIME_TWO = 10005;
72 constexpr int32_t POINTER_ITEM_DOWN_TIME_THREE = 10006;
73 constexpr int32_t POINTER_ITEM_DOWN_TIME_FOUR = 10007;
74 constexpr int32_t POINTER_ITEM_DOWN_TIME_FIVE = 10008;
75 constexpr int32_t POINTER_ITEM_DOWN_TIME_SIX = 10010;
76 constexpr int32_t POINTER_ITEM_WINDOW_ONE = 211;
77 constexpr int32_t POINTER_ITEM_WINDOW_TWO = 300;
78 constexpr int32_t POINTER_ITEM_WINDOW_THREE = 311;
79 constexpr int32_t POINTER_ITEM_WINDOW_FOUR = 600;
80 constexpr double POINTER_AXIS_VALUE = 30.0;
81 constexpr double POINTER_ITEM_PRESSURE_ONE = 5.0;
82 constexpr double POINTER_ITEM_PRESSURE_TWO = 7.0;
83 } // namespace
84
85 class InputManagerSimulateTest : public testing::Test {
86 public:
87 void SetUp();
88 void TearDown();
89 static void SetUpTestCase();
90 std::string GetEventDump();
91 };
92
SetUpTestCase()93 void InputManagerSimulateTest::SetUpTestCase()
94 {
95 ASSERT_TRUE(TestUtil->Init());
96 }
97
SetUp()98 void InputManagerSimulateTest::SetUp()
99 {
100 TestUtil->SetRecvFlag(RECV_FLAG::RECV_FOCUS);
101 }
102
TearDown()103 void InputManagerSimulateTest::TearDown()
104 {
105 TestUtil->AddEventDump("");
106 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
107 }
108
GetEventDump()109 std::string InputManagerSimulateTest::GetEventDump()
110 {
111 return TestUtil->GetEventDump();
112 }
113
114 /**
115 * @tc.name: MultimodalEventHandler_SimulateKeyEvent_001
116 * @tc.desc: Verify simulate the back key is long pressed and lifted
117 * @tc.type: FUNC
118 * @tc.require:
119 */
120 HWTEST_F(InputManagerSimulateTest, InputManagerSimulateTest_SimulateKeyEvent_001, TestSize.Level1)
121 {
122 CALL_TEST_DEBUG;
123 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
124 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
125 ASSERT_TRUE(injectDownEvent != nullptr);
126 KeyEvent::KeyItem kitDown;
127 kitDown.SetDownTime(downTime);
128 kitDown.SetPressed(true);
129 kitDown.SetKeyCode(KeyEvent::KEYCODE_A);
130 injectDownEvent->AddPressedKeyItems(kitDown);
131 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
132 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_A);
133 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
134 SimulateInputEventUtilTest(injectDownEvent);
135 #endif // OHOS_BUILD_ENABLE_KEYBOARD
136
137 std::shared_ptr<KeyEvent> injectUpEvent = KeyEvent::Create();
138 ASSERT_TRUE(injectUpEvent != nullptr);
139 downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
140 KeyEvent::KeyItem kitUp;
141 kitUp.SetPressed(false);
142 kitUp.SetKeyCode(KeyEvent::KEYCODE_A);
143 kitUp.SetDownTime(downTime);
144 injectUpEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
145 injectUpEvent->SetKeyCode(KeyEvent::KEYCODE_A);
146 injectUpEvent->RemoveReleasedKeyItems(kitUp);
147 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
148 SimulateInputEventUtilTest(injectUpEvent);
149 #endif // OHOS_BUILD_ENABLE_KEYBOARD
150 }
151
152 /**
153 * @tc.name: MultimodalEventHandler_SimulateKeyEvent_002
154 * @tc.desc: Verify simulate the back home is pressed
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(InputManagerSimulateTest, InputManagerSimulateTest_SimulateKeyEvent_002, TestSize.Level1)
159 {
160 CALL_TEST_DEBUG;
161 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
162 ASSERT_TRUE(injectDownEvent != nullptr);
163 int64_t downTime = INVAID_VALUE;
164 KeyEvent::KeyItem kitDown;
165 kitDown.SetKeyCode(KeyEvent::KEYCODE_A);
166 kitDown.SetPressed(true);
167 kitDown.SetDownTime(downTime);
168 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_A);
169 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
170 injectDownEvent->AddPressedKeyItems(kitDown);
171 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
172 SimulateInputEventUtilTest(injectDownEvent);
173 #endif // OHOS_BUILD_ENABLE_KEYBOARD
174 }
175
176 /**
177 * @tc.name: MultimodalEventHandler_SimulateKeyEvent_003
178 * @tc.desc: Verify simulate the back key is pressed and lifted
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(InputManagerSimulateTest, InputManagerSimulateTest_SimulateKeyEvent_003, TestSize.Level1)
183 {
184 CALL_TEST_DEBUG;
185 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
186 ASSERT_TRUE(injectDownEvent != nullptr);
187 int64_t downTime = 0;
188 KeyEvent::KeyItem kitDown;
189 kitDown.SetPressed(true);
190 kitDown.SetDownTime(downTime);
191 kitDown.SetKeyCode(KeyEvent::KEYCODE_A);
192 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
193 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_A);
194 injectDownEvent->AddPressedKeyItems(kitDown);
195 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
196 SimulateInputEventUtilTest(injectDownEvent);
197 #endif // OHOS_BUILD_ENABLE_KEYBOARD
198
199 std::shared_ptr<KeyEvent> injectUpEvent = KeyEvent::Create();
200 ASSERT_TRUE(injectUpEvent != nullptr);
201 KeyEvent::KeyItem kitUp;
202 kitUp.SetKeyCode(KeyEvent::KEYCODE_A);
203 kitUp.SetDownTime(downTime);
204 kitUp.SetPressed(false);
205 injectUpEvent->RemoveReleasedKeyItems(kitUp);
206 injectUpEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
207 injectUpEvent->SetKeyCode(KeyEvent::KEYCODE_A);
208 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
209 SimulateInputEventUtilTest(injectUpEvent);
210 #endif // OHOS_BUILD_ENABLE_KEYBOARD
211 }
212
213 /**
214 * @tc.name: MultimodalEventHandler_SimulateKeyEvent_004
215 * @tc.desc: Verify simulate key exception event
216 * @tc.type: FUNC
217 * @tc.require:
218 */
219 HWTEST_F(InputManagerSimulateTest, InputManagerSimulateTest_SimulateKeyEvent_004, TestSize.Level1)
220 {
221 CALL_TEST_DEBUG;
222 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
223 ASSERT_TRUE(injectDownEvent != nullptr);
224 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
225 KeyEvent::KeyItem kitDown;
226 kitDown.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
227 kitDown.SetPressed(true);
228 kitDown.SetDownTime(downTime);
229 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
230 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
231 injectDownEvent->AddPressedKeyItems(kitDown);
232 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
233 TestSimulateInputEvent(injectDownEvent, TestScene::EXCEPTION_TEST);
234 #endif // OHOS_BUILD_ENABLE_KEYBOARD
235 }
236
237 /**
238 * @tc.name: MultimodalEventHandler_SimulateKeyEvent_005
239 * @tc.desc: Verify simulate the fn key is long pressed and lifted
240 * @tc.type: FUNC
241 * @tc.require:
242 */
243 HWTEST_F(InputManagerSimulateTest, InputManagerSimulateTest_SimulateKeyEvent_005, TestSize.Level1)
244 {
245 CALL_TEST_DEBUG;
246 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
247 ASSERT_TRUE(injectDownEvent != nullptr);
248 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
249 KeyEvent::KeyItem kitDown;
250 kitDown.SetKeyCode(KeyEvent::KEYCODE_FN);
251 kitDown.SetPressed(true);
252 kitDown.SetDownTime(downTime);
253 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_FN);
254 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
255 injectDownEvent->AddPressedKeyItems(kitDown);
256 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
257 SimulateInputEventUtilTest(injectDownEvent);
258 #endif // OHOS_BUILD_ENABLE_KEYBOARD
259
260 std::shared_ptr<KeyEvent> injectUpEvent = KeyEvent::Create();
261 ASSERT_TRUE(injectUpEvent != nullptr);
262 downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
263 KeyEvent::KeyItem kitUp;
264 kitUp.SetKeyCode(KeyEvent::KEYCODE_FN);
265 kitUp.SetDownTime(downTime);
266 kitUp.SetPressed(false);
267 injectUpEvent->SetKeyCode(KeyEvent::KEYCODE_FN);
268 injectUpEvent->RemoveReleasedKeyItems(kitUp);
269 injectUpEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
270 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
271 SimulateInputEventUtilTest(injectUpEvent);
272 #endif // OHOS_BUILD_ENABLE_KEYBOARD
273 }
274
275 /**
276 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_001
277 * @tc.desc: Verify simulate screen down event
278 * @tc.type: FUNC
279 * @tc.require:
280 */
281 HWTEST_F(InputManagerSimulateTest, InputManagerSimulateTest_SimulatePointerEvent_001, TestSize.Level1)
282 {
283 CALL_TEST_DEBUG;
284 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent001()};
285 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
286 ASSERT_TRUE(pointerEvent != nullptr);
287 #ifdef OHOS_BUILD_ENABLE_TOUCH
288 SimulateInputEventUtilTest(pointerEvent);
289 #endif // OHOS_BUILD_ENABLE_TOUCH
290 }
291
292 /**
293 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_002
294 * @tc.desc: Verify simulate screen move event
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(InputManagerSimulateTest, InputManagerSimulateTest_SimulatePointerEvent_002, TestSize.Level1)
299 {
300 CALL_TEST_DEBUG;
301 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent002()};
302 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
303 ASSERT_TRUE(pointerEvent != nullptr);
304 #ifdef OHOS_BUILD_ENABLE_TOUCH
305 SimulateInputEventUtilTest(pointerEvent);
306 #endif // OHOS_BUILD_ENABLE_TOUCH
307 }
308
309 /**
310 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_003
311 * @tc.desc: Verify simulate screen up event
312 * @tc.type: FUNC
313 * @tc.require:
314 */
315 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_003, TestSize.Level1)
316 {
317 CALL_TEST_DEBUG;
318 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent003()};
319 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
320 ASSERT_TRUE(pointerEvent != nullptr);
321 #ifdef OHOS_BUILD_ENABLE_TOUCH
322 SimulateInputEventUtilTest(pointerEvent);
323 #endif // OHOS_BUILD_ENABLE_TOUCH
324 }
325
326 /**
327 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_004
328 * @tc.desc: Verify simulate screen exception event
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_004, TestSize.Level1)
333 {
334 CALL_TEST_DEBUG;
335 auto pointerEvent = PointerEvent::Create();
336 ASSERT_TRUE(pointerEvent != nullptr);
337 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
338 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
339 pointerEvent->SetPointerId(POINTER_ID);
340 #ifdef OHOS_BUILD_ENABLE_TOUCH
341 TestSimulateInputEvent(pointerEvent, TestScene::EXCEPTION_TEST);
342 #endif // OHOS_BUILD_ENABLE_TOUCH
343 }
344
345 /**
346 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_005
347 * @tc.desc: Verify simulate mouse down event
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_005, TestSize.Level1)
352 {
353 CALL_TEST_DEBUG;
354 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent005()};
355 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
356 ASSERT_TRUE(pointerEvent != nullptr);
357 #ifdef OHOS_BUILD_ENABLE_POINTER
358 SimulateInputEventUtilTest(pointerEvent);
359 #endif // OHOS_BUILD_ENABLE_POINTER
360 }
361
362 /**
363 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_006
364 * @tc.desc: Verify simulate mouse move event
365 * @tc.type: FUNC
366 * @tc.require:
367 */
368 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_006, TestSize.Level1)
369 {
370 CALL_TEST_DEBUG;
371 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent006()};
372 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
373 ASSERT_TRUE(pointerEvent != nullptr);
374 #ifdef OHOS_BUILD_ENABLE_POINTER
375 SimulateInputEventUtilTest(pointerEvent);
376 #endif // OHOS_BUILD_ENABLE_POINTER
377 }
378
379 /**
380 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_007
381 * @tc.desc: Verify simulate mouse up event
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_007, TestSize.Level1)
386 {
387 CALL_TEST_DEBUG;
388 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent007()};
389 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
390 ASSERT_TRUE(pointerEvent != nullptr);
391 #ifdef OHOS_BUILD_ENABLE_POINTER
392 SimulateInputEventUtilTest(pointerEvent);
393 #endif // OHOS_BUILD_ENABLE_POINTER
394 }
395
396 /**
397 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_008
398 * @tc.desc: Verify simulate mouse exception event
399 * @tc.type: FUNC
400 * @tc.require:
401 */
402 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_008, TestSize.Level1)
403 {
404 CALL_TEST_DEBUG;
405 auto pointerEvent = PointerEvent::Create();
406 ASSERT_TRUE(pointerEvent != nullptr);
407 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
408 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
409 pointerEvent->SetPointerId(POINTER_ID);
410 #ifdef OHOS_BUILD_ENABLE_POINTER
411 TestSimulateInputEvent(pointerEvent, TestScene::EXCEPTION_TEST);
412 #endif // OHOS_BUILD_ENABLE_POINTER
413 }
414
415 /**
416 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_009
417 * @tc.desc: Verify simulate mouse VERTICAL axis event
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_009, TestSize.Level1)
422 {
423 CALL_TEST_DEBUG;
424 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent009()};
425 ASSERT_NE(pointerEvent, nullptr);
426 #ifdef OHOS_BUILD_ENABLE_POINTER
427 SimulateInputEventUtilTest(pointerEvent);
428 #endif // OHOS_BUILD_ENABLE_POINTER
429 }
430
431 /**
432 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_010
433 * @tc.desc: Verify simulate mouse VERTICAL HORIZONTAL axis event
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_010, TestSize.Level1)
438 {
439 CALL_TEST_DEBUG;
440 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent010()};
441 ASSERT_NE(pointerEvent, nullptr);
442 #ifdef OHOS_BUILD_ENABLE_POINTER
443 SimulateInputEventUtilTest(pointerEvent);
444 #endif // OHOS_BUILD_ENABLE_POINTER
445 }
446
447 /**
448 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_011
449 * @tc.desc: Verify simulate mouse AXIS_BEGIN event
450 * @tc.type: FUNC
451 * @tc.require:
452 */
453 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_011, TestSize.Level1)
454 {
455 CALL_TEST_DEBUG;
456 auto pointerEvent = PointerEvent::Create();
457 ASSERT_NE(pointerEvent, nullptr);
458 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, POINTER_AXIS_VALUE);
459 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
460 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN);
461 pointerEvent->SetPointerId(1);
462 PointerEvent::PointerItem item;
463 item.SetDownTime(0);
464 item.SetPressed(false);
465 item.SetPointerId(1);
466
467 item.SetWindowY(POINTER_ITEM_WINDOW_TWO);
468 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_ONE);
469 item.SetWindowX(POINTER_ITEM_WINDOW_TWO);
470 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_FOUR);
471
472 item.SetDeviceId(0);
473 item.SetPressure(0);
474 item.SetWidth(0);
475 item.SetHeight(0);
476 pointerEvent->AddPointerItem(item);
477
478 #ifdef OHOS_BUILD_ENABLE_POINTER
479 SimulateInputEventUtilTest(pointerEvent);
480 #endif // OHOS_BUILD_ENABLE_POINTER
481 }
482
483 /**
484 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_012
485 * @tc.desc: Verify simulate mouse AXIS_UPDATE event
486 * @tc.type: FUNC
487 * @tc.require:
488 */
489 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_012, TestSize.Level1)
490 {
491 CALL_TEST_DEBUG;
492 auto pointerEvent = PointerEvent::Create();
493 ASSERT_NE(pointerEvent, nullptr);
494 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
495 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
496 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, POINTER_AXIS_VALUE);
497 pointerEvent->SetPointerId(1);
498 PointerEvent::PointerItem item;
499 item.SetDownTime(0);
500 item.SetPressed(false);
501 item.SetPointerId(1);
502
503 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_SIX);
504 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_SIX);
505 item.SetWindowY(POINTER_ITEM_WINDOW_FOUR);
506 item.SetWindowX(POINTER_ITEM_WINDOW_FOUR);
507
508 item.SetPressure(0);
509 item.SetHeight(0);
510 item.SetDeviceId(0);
511 item.SetWidth(0);
512 pointerEvent->AddPointerItem(item);
513
514 #ifdef OHOS_BUILD_ENABLE_POINTER
515 SimulateInputEventUtilTest(pointerEvent);
516 #endif // OHOS_BUILD_ENABLE_POINTER
517 }
518
519 /**
520 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_013
521 * @tc.desc: Verify simulate mouse AXIS_END event
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_013, TestSize.Level1)
526 {
527 CALL_TEST_DEBUG;
528 auto pointerEvent = PointerEvent::Create();
529 ASSERT_NE(pointerEvent, nullptr);
530 pointerEvent->SetPointerId(1);
531 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
532 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
533 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, POINTER_AXIS_VALUE);
534 PointerEvent::PointerItem item;
535 item.SetDownTime(0);
536 item.SetPointerId(1);
537 item.SetPressed(false);
538
539 item.SetDeviceId(0);
540 item.SetWidth(0);
541 item.SetHeight(0);
542 item.SetPressure(0);
543
544 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_FIFTEEN);
545 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_SEVEN);
546 item.SetWindowX(POINTER_ITEM_WINDOW_ONE);
547 item.SetWindowY(POINTER_ITEM_WINDOW_THREE);
548
549 pointerEvent->AddPointerItem(item);
550
551 #ifdef OHOS_BUILD_ENABLE_POINTER
552 SimulateInputEventUtilTest(pointerEvent);
553 #endif // OHOS_BUILD_ENABLE_POINTER
554 }
555
556 #ifdef OHOS_BUILD_ENABLE_JOYSTICK
557 /**
558 * @tc.name: MultimodalEventHandler_SimulatePointerEvent_014
559 * @tc.desc: Dispatch joystick event dispatch to focus window
560 * @tc.type: FUNC
561 * @tc.require:
562 */
563 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePointerEvent_014, TestSize.Level1)
564 {
565 CALL_TEST_DEBUG;
566 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent016()};
567 ASSERT_NE(pointerEvent, nullptr);
568 SimulateInputEventUtilTest(pointerEvent);
569 }
570 #endif // OHOS_BUILD_ENABLE_JOYSTICK
571
572 /**
573 * @tc.name: MultimodalEventHandler_SimulatePencil2Event_001
574 * @tc.desc: Verify simulate pencil2 down event
575 * @tc.type: FUNC
576 * @tc.require:
577 */
578 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePencil2Event_001, TestSize.Level1)
579 {
580 CALL_TEST_DEBUG;
581 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent011()};
582 ASSERT_NE(pointerEvent, nullptr);
583 #ifdef OHOS_BUILD_ENABLE_TOUCH
584 SimulateInputEventUtilTest(pointerEvent);
585 #endif // OHOS_BUILD_ENABLE_TOUCH
586 }
587
588 /**
589 * @tc.name: MultimodalEventHandler_SimulatePencil2Event_002
590 * @tc.desc: Verify simulate pencil2 move event
591 * @tc.type: FUNC
592 * @tc.require:
593 */
594 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePencil2Event_002, TestSize.Level1)
595 {
596 CALL_TEST_DEBUG;
597 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent012()};
598 ASSERT_NE(pointerEvent, nullptr);
599 #ifdef OHOS_BUILD_ENABLE_TOUCH
600 SimulateInputEventUtilTest(pointerEvent);
601 #endif // OHOS_BUILD_ENABLE_TOUCH
602 }
603
604 /**
605 * @tc.name: MultimodalEventHandler_SimulatePencil2Event_003
606 * @tc.desc: Verify simulate pencil2 up event
607 * @tc.type: FUNC
608 * @tc.require:
609 */
610 HWTEST_F(InputManagerSimulateTest, MultimodalEventHandler_SimulatePencil2Event_003, TestSize.Level1)
611 {
612 CALL_TEST_DEBUG;
613 std::shared_ptr<PointerEvent> pointerEvent{InputManagerUtil::SetupPointerEvent013()};
614 ASSERT_NE(pointerEvent, nullptr);
615 #ifdef OHOS_BUILD_ENABLE_TOUCH
616 SimulateInputEventUtilTest(pointerEvent);
617 #endif // OHOS_BUILD_ENABLE_TOUCH
618 }
619
620 /**
621 * @tc.name: InputManager_Pencil2InputEvent_004
622 * @tc.desc: Verify simulate exception event
623 * @tc.type: FUNC
624 * @tc.require:
625 */
626 HWTEST_F(InputManagerSimulateTest, InputManager_Pencil2InputEvent_004, TestSize.Level1)
627 {
628 CALL_TEST_DEBUG;
629 auto pointerEvent = PointerEvent::Create();
630 ASSERT_TRUE(pointerEvent != nullptr);
631 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
632 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
633 pointerEvent->SetPointerId(POINTER_ID);
634 #ifdef OHOS_BUILD_ENABLE_TOUCH
635 TestSimulateInputEvent(pointerEvent, TestScene::EXCEPTION_TEST);
636 #endif // OHOS_BUILD_ENABLE_TOUCH
637 }
638
639 /**
640 * @tc.name: TestInputEventInterceptor_001
641 * @tc.desc: Verify mouse down event interceptor
642 * @tc.type: FUNC
643 * @tc.require:
644 */
645 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_001, TestSize.Level1)
646 {
647 CALL_TEST_DEBUG;
648 auto pointerEvent = PointerEvent::Create();
649 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
650 ASSERT_TRUE(pointerEvent != nullptr);
651 PointerEvent::PointerItem item;
652 item.SetPressed(true);
653 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_ELEVEN);
654 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_NINE);
655 item.SetDeviceId(1);
656 item.SetDownTime(POINTER_ITEM_DOWN_TIME_SIX);
657 item.SetPointerId(DEFAULT_POINTER_ID);
658 pointerEvent->AddPointerItem(item);
659 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
660 pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
661 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
662
663 auto interceptor = GetPtr<InputEventCallback>();
664 int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
665 InputManagerUtil::TestInterceptorIdAndPointerEvent(interceptorId, pointerEvent);
666 }
667
668 /**
669 * @tc.name: TestInputEventInterceptor_002
670 * @tc.desc: Verify mouse move event interceptor
671 * @tc.type: FUNC
672 * @tc.require:
673 */
674 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_002, TestSize.Level1)
675 {
676 CALL_TEST_DEBUG;
677 auto pointerEvent = PointerEvent::Create();
678 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
679 ASSERT_TRUE(pointerEvent != nullptr);
680 PointerEvent::PointerItem item;
681 item.SetDeviceId(1);
682 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_ELEVEN);
683 item.SetPressed(true);
684 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_NINE);
685 item.SetDownTime(POINTER_ITEM_DOWN_TIME_SIX);
686 item.SetPointerId(DEFAULT_POINTER_ID);
687 pointerEvent->AddPointerItem(item);
688 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
689 pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
690 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
691
692 auto interceptor = GetPtr<InputEventCallback>();
693 int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
694 InputManagerUtil::TestInterceptorIdAndPointerEvent(interceptorId, pointerEvent);
695 }
696
697 /**
698 * @tc.name: TestInputEventInterceptor_003
699 * @tc.desc: Verify mouse up event interceptor
700 * @tc.type: FUNC
701 * @tc.require:
702 */
703 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_003, TestSize.Level1)
704 {
705 CALL_TEST_DEBUG;
706 auto pointerEvent = PointerEvent::Create();
707 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
708 ASSERT_TRUE(pointerEvent != nullptr);
709 PointerEvent::PointerItem item;
710 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_ELEVEN);
711 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_NINE);
712 item.SetPointerId(DEFAULT_POINTER_ID);
713 item.SetDownTime(POINTER_ITEM_DOWN_TIME_SIX);
714 item.SetDeviceId(1);
715 item.SetPressed(true);
716 pointerEvent->AddPointerItem(item);
717 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
718 pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
719 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
720
721 auto interceptor = GetPtr<InputEventCallback>();
722 int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
723 InputManagerUtil::TestInterceptorIdAndPointerEvent(interceptorId, pointerEvent);
724 }
725
726 /**
727 * @tc.name: TestInputEventInterceptor_004
728 * @tc.desc: Verify multiple interceptor
729 * @tc.type: FUNC
730 * @tc.require:
731 */
732 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_004, TestSize.Level1)
733 {
734 CALL_TEST_DEBUG;
735 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
736 auto pointerEvent = PointerEvent::Create();
737 ASSERT_NE(pointerEvent, nullptr);
738 PointerEvent::PointerItem item;
739 item.SetPointerId(0);
740 item.SetDownTime(POINTER_ITEM_DOWN_TIME_FIVE);
741 item.SetPressed(true);
742 item.SetDeviceId(1);
743 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_TWELVE);
744 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_SEVENTEEN);
745 pointerEvent->AddPointerItem(item);
746 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
747 pointerEvent->SetPointerId(0);
748 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
749
750 const std::vector<int32_t>::size_type N_TEST_CASES{SIZE_TYPE_CASE};
751 std::vector<int32_t> ids(N_TEST_CASES);
752 auto interceptor = GetPtr<InputEventCallback>();
753
754 for (std::vector<int32_t>::size_type i = 0; i < N_TEST_CASES; ++i) {
755 ids[i] = InputManager::GetInstance()->AddInterceptor(interceptor);
756 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
757 EXPECT_TRUE(IsValidHandlerId(ids[i]));
758 #else
759 EXPECT_EQ(ids[i], ERROR_UNSUPPORT);
760 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
761 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
762 }
763
764 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
765
766 for (size_t i = 0; i < ids.size(); ++i) {
767 std::string sPointerEs = GetEventDump();
768 MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
769 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
770 if (i == 0) {
771 ASSERT_TRUE(!sPointerEs.empty());
772 } else {
773 ASSERT_TRUE(sPointerEs.empty());
774 }
775 #else
776 ASSERT_TRUE(sPointerEs.empty());
777 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_INTERCEPTOR
778 if (IsValidHandlerId(ids[i])) {
779 InputManager::GetInstance()->RemoveInterceptor(ids[i]);
780 }
781 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
782 }
783 }
784
785 /**
786 * @tc.name: TestInputEventInterceptor_005
787 * @tc.desc: Verify mouse button interceptor
788 * @tc.type: FUNC
789 * @tc.require:
790 */
791 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_005, TestSize.Level1)
792 {
793 CALL_TEST_DEBUG;
794 auto pointerEvent = PointerEvent::Create();
795 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
796 ASSERT_TRUE(pointerEvent != nullptr);
797 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
798 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
799 pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
800 pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
801 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
802 PointerEvent::PointerItem item;
803 item.SetPointerId(DEFAULT_POINTER_ID);
804 item.SetDownTime(GetNanoTime() / NANOSECOND_TO_MILLISECOND);
805 item.SetPressed(true);
806 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_SEVEN);
807 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_NINE);
808 pointerEvent->AddPointerItem(item);
809
810 auto interceptor = GetPtr<InputEventCallback>();
811 int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
812 InputManagerUtil::TestInterceptorIdAndPointerEvent(interceptorId, pointerEvent);
813 }
814
815 /**
816 * @tc.name: TestInputEventInterceptor_006
817 * @tc.desc: Verify touchscreen interceptor
818 * @tc.type: FUNC
819 * @tc.require:
820 */
821 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_006, TestSize.Level1)
822 {
823 CALL_TEST_DEBUG;
824 auto pointerEvent = PointerEvent::Create();
825 pointerEvent->AddFlag(PointerEvent::EVENT_FLAG_NO_INTERCEPT);
826 ASSERT_TRUE(pointerEvent != nullptr);
827 PointerEvent::PointerItem item;
828 item.SetPointerId(0);
829 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_FIVE);
830 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_FOUR);
831 item.SetPressure(POINTER_ITEM_PRESSURE_ONE);
832 item.SetDeviceId(1);
833 pointerEvent->AddPointerItem(item);
834 item.SetPointerId(1);
835 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_SIXTEEN);
836 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_SIXTEEN);
837 item.SetPressure(POINTER_ITEM_PRESSURE_TWO);
838 item.SetDeviceId(1);
839 pointerEvent->AddPointerItem(item);
840 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
841 pointerEvent->SetPointerId(1);
842 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
843
844 auto interceptor = GetPtr<InputEventCallback>();
845 int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
846 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
847 EXPECT_TRUE(IsValidHandlerId(interceptorId));
848 #else
849 EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
850 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
851 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
852
853 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
854 SimulateInputEventUtilTest(pointerEvent);
855 #endif // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_INTERCEPTOR
856
857 if (IsValidHandlerId(interceptorId)) {
858 InputManager::GetInstance()->RemoveInterceptor(interceptorId);
859 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
860 }
861 }
862
863 /**
864 * @tc.name: TestInputEventInterceptor_007
865 * @tc.desc: Verify key interceptor
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_007, TestSize.Level1)
870 {
871 CALL_TEST_DEBUG;
872 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
873 ASSERT_TRUE(injectDownEvent != nullptr);
874 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
875 KeyEvent::KeyItem kitDown;
876 kitDown.SetKeyCode(KeyEvent::KEYCODE_A);
877 kitDown.SetDownTime(downTime);
878 kitDown.SetPressed(true);
879 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
880 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_A);
881 injectDownEvent->AddPressedKeyItems(kitDown);
882
883 auto interceptor = GetPtr<InputEventCallback>();
884 int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
885 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
886 EXPECT_TRUE(IsValidHandlerId(interceptorId));
887 #else
888 EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
889 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
890 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
891
892 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
893 SimulateInputEventUtilTest(injectDownEvent);
894 #endif // OHOS_BUILD_ENABLE_KEYBOARD
895
896 if (IsValidHandlerId(interceptorId)) {
897 InputManager::GetInstance()->RemoveInterceptor(interceptorId);
898 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
899 }
900 }
901
902 /**
903 * @tc.name: TestInputEventInterceptor_008
904 * @tc.desc: Verify touchscreen interceptor
905 * @tc.type: FUNC
906 * @tc.require:
907 */
908 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_008, TestSize.Level1)
909 {
910 CALL_TEST_DEBUG;
911 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
912 auto pointerEvent = PointerEvent::Create();
913 ASSERT_NE(pointerEvent, nullptr);
914 PointerEvent::PointerItem item;
915 item.SetDownTime(POINTER_ITEM_DOWN_TIME_FOUR);
916 item.SetPointerId(0);
917 item.SetDeviceId(1);
918 item.SetPressed(true);
919 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_TEN);
920 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_TWELVE);
921 pointerEvent->SetPointerId(0);
922 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
923 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
924 pointerEvent->AddPointerItem(item);
925
926 auto interceptor = GetPtr<InputEventCallback>();
927 int32_t interceptorId = InputManager::GetInstance()->AddInterceptor(interceptor);
928 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
929 EXPECT_TRUE(IsValidHandlerId(interceptorId));
930 #else
931 EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
932 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
933 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
934
935 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
936
937 std::string sPointerEs = GetEventDump();
938 MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
939 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
940 ASSERT_TRUE(!sPointerEs.empty());
941 #else
942 ASSERT_TRUE(sPointerEs.empty());
943 #endif // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_INTERCEPTOR
944 if (IsValidHandlerId(interceptorId)) {
945 InputManager::GetInstance()->RemoveInterceptor(interceptorId);
946 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
947 }
948 }
949
950 /**
951 * @tc.name: TestInputEventInterceptor_009
952 * @tc.desc: Verify mouse interceptor
953 * @tc.type: FUNC
954 * @tc.require:
955 */
956 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_009, TestSize.Level1)
957 {
958 CALL_TEST_DEBUG;
959 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
960 auto pointerEvent = PointerEvent::Create();
961 ASSERT_NE(pointerEvent, nullptr);
962 PointerEvent::PointerItem item;
963 item.SetPointerId(0);
964 item.SetDownTime(POINTER_ITEM_DOWN_TIME_THREE);
965 item.SetPressed(true);
966 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_ELEVEN);
967 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_FIFTEEN);
968 item.SetDeviceId(1);
969 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
970 pointerEvent->AddPointerItem(item);
971 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
972 pointerEvent->SetPointerId(0);
973
974 auto interceptor = GetPtr<InputEventCallback>();
975 int32_t interceptorId = InputManager::GetInstance()->AddInterceptor(interceptor);
976 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
977 EXPECT_TRUE(IsValidHandlerId(interceptorId));
978 #else
979 EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
980 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
981 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
982
983 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
984
985 std::string sPointerEs = GetEventDump();
986 MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
987 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
988 ASSERT_TRUE(!sPointerEs.empty());
989 #else
990 ASSERT_TRUE(sPointerEs.empty());
991 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_INTERCEPTOR
992 if (IsValidHandlerId(interceptorId)) {
993 InputManager::GetInstance()->RemoveInterceptor(interceptorId);
994 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
995 }
996 }
997
998 /**
999 * @tc.name: TestInputEventInterceptor_010
1000 * @tc.desc: Verify volume key interceptor
1001 * @tc.type: FUNC
1002 * @tc.require:
1003 */
1004 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_010, TestSize.Level1)
1005 {
1006 CALL_TEST_DEBUG;
1007 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
1008 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
1009 ASSERT_NE(injectDownEvent, nullptr);
1010 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1011 KeyEvent::KeyItem kitDown;
1012 kitDown.SetDownTime(downTime);
1013 kitDown.SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
1014 kitDown.SetPressed(true);
1015 kitDown.SetDeviceId(1);
1016 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
1017 injectDownEvent->AddPressedKeyItems(kitDown);
1018 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
1019
1020 auto interceptor = GetPtr<InputEventCallback>();
1021 int32_t interceptorId{InputManager::GetInstance()->AddInterceptor(interceptor)};
1022 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
1023 EXPECT_TRUE(IsValidHandlerId(interceptorId));
1024 #else
1025 EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
1026 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
1027 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1028
1029 InputManager::GetInstance()->SimulateInputEvent(injectDownEvent);
1030
1031 std::string sPointerEs = GetEventDump();
1032 MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
1033 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
1034 ASSERT_TRUE(!sPointerEs.empty());
1035 #else
1036 ASSERT_TRUE(sPointerEs.empty());
1037 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR
1038 if (IsValidHandlerId(interceptorId)) {
1039 InputManager::GetInstance()->RemoveInterceptor(interceptorId);
1040 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1041 }
1042 }
1043
1044 /**
1045 * @tc.name: TestInputEventInterceptor_011
1046 * @tc.desc: Verify space key interceptor
1047 * @tc.type: FUNC
1048 * @tc.require:
1049 */
1050 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_011, TestSize.Level1)
1051 {
1052 CALL_TEST_DEBUG;
1053 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
1054 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
1055 ASSERT_NE(injectDownEvent, nullptr);
1056 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1057 KeyEvent::KeyItem kitDown;
1058 kitDown.SetKeyCode(KeyEvent::KEYCODE_SPACE);
1059 kitDown.SetDownTime(downTime);
1060 kitDown.SetDeviceId(1);
1061 kitDown.SetPressed(true);
1062 injectDownEvent->AddPressedKeyItems(kitDown);
1063 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_SPACE);
1064 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
1065
1066 auto interceptor = GetPtr<InputEventCallback>();
1067 uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX);
1068 int32_t interceptorId{
1069 InputManager::GetInstance()->AddInterceptor(interceptor, INTERCEPTOR_PRIORITY_ONE, touchTags)};
1070 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
1071 EXPECT_TRUE(IsValidHandlerId(interceptorId));
1072 #else
1073 EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
1074 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
1075 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1076
1077 InputManager::GetInstance()->SimulateInputEvent(injectDownEvent);
1078
1079 std::string sPointerEs = GetEventDump();
1080 MMI_HILOGD("PriorityLevel Test:sPointerEs:%{public}s", sPointerEs.c_str());
1081 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
1082 ASSERT_TRUE(!sPointerEs.empty());
1083 #else
1084 ASSERT_TRUE(sPointerEs.empty());
1085 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR
1086 if (IsValidHandlerId(interceptorId)) {
1087 InputManager::GetInstance()->RemoveInterceptor(interceptorId);
1088 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1089 }
1090 }
1091
1092 /**
1093 * @tc.name: TestInputEventInterceptor_012
1094 * @tc.desc: Verify mouse interceptor
1095 * @tc.type: FUNC
1096 * @tc.require:
1097 */
1098 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_012, TestSize.Level1)
1099 {
1100 CALL_TEST_DEBUG;
1101 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
1102 auto pointerEvent = PointerEvent::Create();
1103 ASSERT_NE(pointerEvent, nullptr);
1104 PointerEvent::PointerItem item;
1105 item.SetPointerId(0);
1106 item.SetDownTime(POINTER_ITEM_DOWN_TIME_TWO);
1107 item.SetPressed(true);
1108 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_SEVENTEEN);
1109 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_FIVE);
1110 item.SetDeviceId(1);
1111 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
1112 pointerEvent->SetPointerId(0);
1113 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1114 pointerEvent->AddPointerItem(item);
1115
1116 auto interceptor = GetPtr<InputEventCallback>();
1117 uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX);
1118 int32_t interceptorId =
1119 InputManager::GetInstance()->AddInterceptor(interceptor, INTERCEPTOR_PRIORITY_ONE, touchTags);
1120 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
1121 EXPECT_TRUE(IsValidHandlerId(interceptorId));
1122 #else
1123 EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
1124 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
1125 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1126
1127 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1128
1129 std::string sPointerEs = GetEventDump();
1130 MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
1131 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
1132 ASSERT_TRUE(!sPointerEs.empty());
1133 #else
1134 ASSERT_TRUE(sPointerEs.empty());
1135 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_INTERCEPTOR
1136 if (IsValidHandlerId(interceptorId)) {
1137 InputManager::GetInstance()->RemoveInterceptor(interceptorId);
1138 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1139 }
1140 }
1141
1142 /**
1143 * @tc.name: TestInputEventInterceptor_013
1144 * @tc.desc: Verify mouse interceptor
1145 * @tc.type: FUNC
1146 * @tc.require:
1147 */
1148 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_013, TestSize.Level1)
1149 {
1150 CALL_TEST_DEBUG;
1151 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
1152 auto pointerEvent = PointerEvent::Create();
1153 ASSERT_NE(pointerEvent, nullptr);
1154 PointerEvent::PointerItem item;
1155 item.SetPressed(true);
1156 item.SetPointerId(0);
1157 item.SetDownTime(POINTER_ITEM_DOWN_TIME_ONE);
1158 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_TWO);
1159 item.SetDeviceId(1);
1160 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_TWO);
1161 pointerEvent->AddPointerItem(item);
1162 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1163 pointerEvent->SetPointerId(0);
1164 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
1165
1166 auto interceptor1 = GetPtr<PriorityHighCallback>();
1167 auto interceptor2 = GetPtr<PriorityMiddleCallback>();
1168 uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX);
1169 int32_t interceptorId1{
1170 InputManager::GetInstance()->AddInterceptor(interceptor1, INTERCEPTOR_PRIORITY_ONE, touchTags)};
1171 int32_t interceptorId2{
1172 InputManager::GetInstance()->AddInterceptor(interceptor2, INTERCEPTOR_PRIORITY_TWO, touchTags)};
1173 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
1174 EXPECT_TRUE(IsValidHandlerId(interceptorId1));
1175 EXPECT_TRUE(IsValidHandlerId(interceptorId2));
1176 #else
1177 EXPECT_EQ(interceptorId1, ERROR_UNSUPPORT);
1178 EXPECT_EQ(interceptorId2, ERROR_UNSUPPORT);
1179 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
1180 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1181 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1182
1183 for (size_t i = 0; i < INPUT_INTERCEPTOR_ONE; ++i) {
1184 std::string sPointerEs = GetEventDump();
1185 MMI_HILOGD("sPointerEs:%{public}s", sPointerEs.c_str());
1186 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
1187 if (i == 0) {
1188 EXPECT_EQ(sPointerEs, "Call high interceptor");
1189 } else {
1190 ASSERT_TRUE(sPointerEs.empty());
1191 }
1192 #else
1193 ASSERT_TRUE(sPointerEs.empty());
1194 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_INTERCEPTOR
1195 }
1196
1197 InputManagerUtil::TestInterceptorId(interceptorId1, interceptorId2);
1198 }
1199
1200 /**
1201 * @tc.name: TestInputEventInterceptor_014
1202 * @tc.desc: Verify space key interceptor
1203 * @tc.type: FUNC
1204 * @tc.require:
1205 */
1206 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_014, TestSize.Level1)
1207 {
1208 CALL_TEST_DEBUG;
1209 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
1210 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
1211 ASSERT_NE(injectDownEvent, nullptr);
1212 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1213 KeyEvent::KeyItem kitDown;
1214 kitDown.SetDeviceId(1);
1215 kitDown.SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
1216 kitDown.SetPressed(true);
1217 kitDown.SetDownTime(downTime);
1218 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
1219 injectDownEvent->AddPressedKeyItems(kitDown);
1220 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
1221
1222 auto interceptor2 = GetPtr<PriorityMiddleCallback>();
1223 auto interceptor1 = GetPtr<PriorityHighCallback>();
1224 uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX);
1225 int32_t interceptorId2{
1226 InputManager::GetInstance()->AddInterceptor(interceptor2, INTERCEPTOR_PRIORITY_TWO, touchTags)};
1227 int32_t interceptorId1{
1228 InputManager::GetInstance()->AddInterceptor(interceptor1, INTERCEPTOR_PRIORITY_ONE, touchTags)};
1229 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
1230 EXPECT_TRUE(IsValidHandlerId(interceptorId1));
1231 EXPECT_TRUE(IsValidHandlerId(interceptorId2));
1232 #else
1233 EXPECT_EQ(interceptorId1, ERROR_UNSUPPORT);
1234 EXPECT_EQ(interceptorId2, ERROR_UNSUPPORT);
1235 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
1236 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1237
1238 InputManager::GetInstance()->SimulateInputEvent(injectDownEvent);
1239 for (size_t i = 0; i < INPUT_INTERCEPTOR_ONE; ++i) {
1240 std::string sPointerEs = GetEventDump();
1241 MMI_HILOGD("PriorityLevel Test:sPointerEs:%{public}s", sPointerEs.c_str());
1242 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
1243 if (i == 0) {
1244 EXPECT_EQ(sPointerEs, "Call high interceptor");
1245 } else {
1246 ASSERT_TRUE(sPointerEs.empty());
1247 }
1248 #else
1249 ASSERT_TRUE(sPointerEs.empty());
1250 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR
1251 }
1252
1253 InputManagerUtil::TestInterceptorId(interceptorId1, interceptorId2);
1254 }
1255
1256 /**
1257 * @tc.name: TestInputEventInterceptor_015
1258 * @tc.desc: Verify space key interceptor
1259 * @tc.type: FUNC
1260 * @tc.require:
1261 */
1262 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_015, TestSize.Level1)
1263 {
1264 CALL_TEST_DEBUG;
1265 TestUtil->SetRecvFlag(RECV_FLAG::RECV_INTERCEPT);
1266 std::shared_ptr<KeyEvent> injectDownEvent = KeyEvent::Create();
1267 ASSERT_NE(injectDownEvent, nullptr);
1268 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1269 KeyEvent::KeyItem kitDown;
1270 kitDown.SetPressed(true);
1271 kitDown.SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
1272 kitDown.SetDeviceId(1);
1273 kitDown.SetDownTime(downTime);
1274 injectDownEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
1275 injectDownEvent->AddPressedKeyItems(kitDown);
1276 injectDownEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
1277
1278 uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX);
1279 int32_t interceptorId1{InputManager::GetInstance()->AddInterceptor(
1280 GetPtr<PriorityHighCallback>(), INTERCEPTOR_PRIORITY_TWO, touchTags)};
1281 int32_t interceptorId2{InputManager::GetInstance()->AddInterceptor(
1282 GetPtr<PriorityMiddleCallback>(), INTERCEPTOR_PRIORITY_THREE, touchTags)};
1283 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
1284 EXPECT_TRUE(IsValidHandlerId(interceptorId1));
1285 EXPECT_TRUE(IsValidHandlerId(interceptorId2));
1286 #else
1287 EXPECT_EQ(interceptorId1, ERROR_UNSUPPORT);
1288 EXPECT_EQ(interceptorId2, ERROR_UNSUPPORT);
1289 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
1290 if (IsValidHandlerId(interceptorId1)) {
1291 InputManager::GetInstance()->RemoveInterceptor(interceptorId1);
1292 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1293 }
1294
1295 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1296 InputManager::GetInstance()->SimulateInputEvent(injectDownEvent);
1297 for (size_t i = 0; i < INPUT_INTERCEPTOR_TWO; ++i) {
1298 std::string sPointerEs = GetEventDump();
1299 MMI_HILOGD("PriorityLevel Test:sPointerEs:%{public}s", sPointerEs.c_str());
1300 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
1301 if (i == 0) {
1302 EXPECT_EQ(sPointerEs, "Call middle interceptor");
1303 } else {
1304 ASSERT_TRUE(sPointerEs.empty());
1305 }
1306 #else
1307 ASSERT_TRUE(sPointerEs.empty());
1308 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR
1309 }
1310
1311 if (IsValidHandlerId(interceptorId2)) {
1312 InputManager::GetInstance()->RemoveInterceptor(interceptorId2);
1313 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1314 }
1315 }
1316
1317 /**
1318 * @tc.name: TestInputEventInterceptor_016
1319 * @tc.desc: Verify keyevent interceptor
1320 * @tc.type: FUNC
1321 * @tc.require:
1322 */
1323 HWTEST_F(InputManagerSimulateTest, TestInputEventInterceptor_016, TestSize.Level1)
1324 {
1325 CALL_TEST_DEBUG;
__anon1f5ff0550202(std::shared_ptr<KeyEvent> keyEvent) 1326 auto fun = [](std::shared_ptr<KeyEvent> keyEvent) { MMI_HILOGD("Add interceptor success"); };
1327 int32_t interceptorId = InputManager::GetInstance()->AddInterceptor(fun);
1328 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
1329 ASSERT_NE(interceptorId, INVALID_HANDLER_ID);
1330 #else
1331 ASSERT_EQ(interceptorId, ERROR_UNSUPPORT);
1332 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR
1333 if (IsValidHandlerId(interceptorId)) {
1334 InputManager::GetInstance()->RemoveInterceptor(interceptorId);
1335 }
1336 }
1337
1338 /**
1339 * @tc.name: InputManager_TouchPadSimulateInputEvent_001
1340 * @tc.desc: Verify touchpad simulate and monitor
1341 * @tc.type: FUNC
1342 * @tc.require:
1343 */
1344 HWTEST_F(InputManagerSimulateTest, InputManager_TouchPadSimulateInputEvent_001, TestSize.Level1)
1345 {
1346 CALL_TEST_DEBUG;
1347 auto callbackPtr = GetPtr<InputEventCallback>();
1348 ASSERT_NE(callbackPtr, nullptr);
1349 int32_t monitorId{InputManagerUtil::TestAddMonitor(callbackPtr)};
1350 #ifdef OHOS_BUILD_ENABLE_MONITOR
1351 EXPECT_TRUE(monitorId >= MIN_HANDLER_ID);
1352 #else
1353 EXPECT_EQ(monitorId, ERROR_UNSUPPORT);
1354 #endif // OHOS_BUILD_ENABLE_MONITOR
1355 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1356
1357 int64_t stepTime = GetSysClockTime();
1358 auto pointerEvent = PointerEvent::Create();
1359 ASSERT_TRUE(pointerEvent != nullptr);
1360 PointerEvent::PointerItem item{};
1361 item.SetPointerId(DEFAULT_POINTER_ID);
1362 item.SetDownTime(stepTime);
1363 item.SetPressed(true);
1364 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_NINE);
1365 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_ELEVEN);
1366 item.SetDeviceId(DEFAULT_DEVICE_ID);
1367 pointerEvent->AddPointerItem(item);
1368 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1369 pointerEvent->SetActionTime(stepTime);
1370 pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
1371 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
1372
1373 InputManagerUtil::TestMonitor(monitorId, pointerEvent);
1374 }
1375
1376 /**
1377 * @tc.name: InputManager_TouchPadSimulateInputEvent_002
1378 * @tc.desc: Verify touchpad simulate and monitor
1379 * @tc.type: FUNC
1380 * @tc.require:
1381 */
1382 HWTEST_F(InputManagerSimulateTest, InputManager_TouchPadSimulateInputEvent_002, TestSize.Level1)
1383 {
1384 CALL_TEST_DEBUG;
1385 auto callbackPtr = GetPtr<InputEventCallback>();
1386 ASSERT_NE(callbackPtr, nullptr);
1387 int32_t monitorId{InputManagerUtil::TestAddMonitor(callbackPtr)};
1388 #ifdef OHOS_BUILD_ENABLE_MONITOR
1389 EXPECT_TRUE(monitorId >= MIN_HANDLER_ID);
1390 #else
1391 EXPECT_EQ(monitorId, ERROR_UNSUPPORT);
1392 #endif // OHOS_BUILD_ENABLE_MONITOR
1393 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1394
1395 int64_t measureTime = GetSysClockTime();
1396 auto pointerEvent = PointerEvent::Create();
1397 ASSERT_TRUE(pointerEvent != nullptr);
1398 PointerEvent::PointerItem item{};
1399 item.SetPointerId(DEFAULT_POINTER_ID);
1400 item.SetDownTime(measureTime);
1401 item.SetPressed(true);
1402 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_ONE);
1403 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_TEN);
1404 item.SetDeviceId(DEFAULT_DEVICE_ID);
1405 pointerEvent->AddPointerItem(item);
1406 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1407 pointerEvent->SetActionTime(measureTime);
1408 pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
1409 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
1410
1411 InputManagerUtil::TestMonitor(monitorId, pointerEvent);
1412 }
1413
1414 /**
1415 * @tc.name: InputManager_TouchPadSimulateInputEvent_003
1416 * @tc.desc: Verify touchpad simulate and monitor
1417 * @tc.type: FUNC
1418 * @tc.require:
1419 */
1420 HWTEST_F(InputManagerSimulateTest, InputManager_TouchPadSimulateInputEvent_003, TestSize.Level1)
1421 {
1422 CALL_TEST_DEBUG;
1423 auto callbackPtr = GetPtr<InputEventCallback>();
1424 ASSERT_NE(callbackPtr, nullptr);
1425 int32_t monitorId{InputManagerUtil::TestAddMonitor(callbackPtr)};
1426 #ifdef OHOS_BUILD_ENABLE_MONITOR
1427 EXPECT_TRUE(monitorId >= MIN_HANDLER_ID);
1428 #else
1429 EXPECT_EQ(monitorId, ERROR_UNSUPPORT);
1430 #endif // OHOS_BUILD_ENABLE_MONITOR
1431 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1432
1433 int64_t deedTime = GetSysClockTime();
1434 auto pointerEvent = PointerEvent::Create();
1435 ASSERT_TRUE(pointerEvent != nullptr);
1436 PointerEvent::PointerItem item{};
1437 item.SetPointerId(DEFAULT_POINTER_ID);
1438 item.SetDownTime(deedTime);
1439 item.SetPressed(false);
1440 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_EIGHT);
1441 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_EIGHT);
1442 item.SetDeviceId(DEFAULT_DEVICE_ID);
1443 pointerEvent->AddPointerItem(item);
1444 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1445 pointerEvent->SetActionTime(deedTime);
1446 pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
1447 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
1448
1449 InputManagerUtil::TestMonitor(monitorId, pointerEvent);
1450 }
1451
1452 /**
1453 * @tc.name: InputManager_TouchPadSimulateInputEvent_004
1454 * @tc.desc: Verify touchpad simulate and monitor
1455 * @tc.type: FUNC
1456 * @tc.require:
1457 */
1458 HWTEST_F(InputManagerSimulateTest, InputManager_TouchPadSimulateInputEvent_004, TestSize.Level1)
1459 {
1460 CALL_TEST_DEBUG;
1461 auto callbackPtr = GetPtr<InputEventCallback>();
1462 ASSERT_NE(callbackPtr, nullptr);
1463 int32_t monitorId{InputManagerUtil::TestAddMonitor(callbackPtr)};
1464 #ifdef OHOS_BUILD_ENABLE_MONITOR
1465 EXPECT_TRUE(monitorId >= MIN_HANDLER_ID);
1466 #else
1467 EXPECT_EQ(monitorId, ERROR_UNSUPPORT);
1468 #endif // OHOS_BUILD_ENABLE_MONITOR
1469 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1470
1471 int64_t actionTime = GetSysClockTime();
1472 auto pointerEvent = PointerEvent::Create();
1473 ASSERT_TRUE(pointerEvent != nullptr);
1474 PointerEvent::PointerItem item{};
1475 item.SetPointerId(DEFAULT_POINTER_ID);
1476 item.SetDownTime(actionTime);
1477 item.SetPressed(true);
1478 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_THREE);
1479 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_THREE);
1480 item.SetDeviceId(DEFAULT_DEVICE_ID);
1481 pointerEvent->AddPointerItem(item);
1482 item.SetPointerId(1);
1483 item.SetDownTime(actionTime);
1484 item.SetPressed(true);
1485 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_THIRTEEN);
1486 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_THIRTEEN);
1487 item.SetDeviceId(DEFAULT_DEVICE_ID);
1488 pointerEvent->AddPointerItem(item);
1489 item.SetPointerId(2);
1490 item.SetDownTime(actionTime);
1491 item.SetPressed(true);
1492 item.SetDisplayX(POINTER_ITEM_DISPLAY_X_FOURTEEN);
1493 item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_FOURTEEN);
1494 item.SetDeviceId(DEFAULT_DEVICE_ID);
1495 pointerEvent->AddPointerItem(item);
1496 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1497 pointerEvent->SetActionTime(actionTime);
1498 pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
1499 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
1500
1501 InputManagerUtil::TestMonitor(monitorId, pointerEvent);
1502 }
1503 } // namespace MMI
1504 } // namespace OHOS