1 /*
2  * Copyright (c) 2021-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 "axis_event.h"
17 #include "define_multimodal.h"
18 #include "event_util_test.h"
19 #include "input_device.h"
20 #include "input_event.h"
21 #include "proto.h"
22 #include "util.h"
23 
24 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "PointerEventTest"
26 
27 namespace OHOS {
28 namespace MMI {
29 namespace {
30 using namespace testing::ext;
31 } // namespace
32 class PointerEventTest : public testing::Test {
33 public:
34     static void SetUpTestCase(void);
35     static std::shared_ptr<PointerEvent> CreatePointEvent();
36 };
37 
SetUpTestCase(void)38 void PointerEventTest::SetUpTestCase(void)
39 {
40     ASSERT_TRUE(TestUtil->Init());
41 }
42 
43 #ifdef OHOS_BUILD_ENABLE_POINTER
CreatePointEvent()44 std::shared_ptr<PointerEvent> PointerEventTest::CreatePointEvent()
45 {
46     auto pointerEvent = PointerEvent::Create();
47     CHKPP(pointerEvent);
48     int64_t downTime = GetMillisTime();
49     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
50     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
51     pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
52     pointerEvent->SetPointerId(1);
53     pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
54     PointerEvent::PointerItem item;
55     item.SetPointerId(1);
56     item.SetDownTime(downTime);
57     item.SetPressed(true);
58 
59     item.SetDisplayX(623);
60     item.SetDisplayY(823);
61     item.SetWindowX(600);
62     item.SetWindowY(800);
63 
64     item.SetWidth(0);
65     item.SetHeight(0);
66     item.SetPressure(0);
67     item.SetDeviceId(0);
68     pointerEvent->AddPointerItem(item);
69     return pointerEvent;
70 }
71 
72 /**
73  * @tc.name: PointerEventTest_keyEventAndPointerEvent_001
74  * @tc.desc: Verify ctrl(left) + point event
75  * @tc.type: FUNC
76  * @tc.require: AR000GOACS
77  * @tc.author: yangguang
78  */
79 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_001, TestSize.Level1)
80 {
81     CALL_TEST_DEBUG;
82     sleep(10);
83     std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
84     ASSERT_NE(pointerEvent, nullptr);
85     std::vector<int32_t> pressedKeys { KeyEvent::KEYCODE_CTRL_LEFT };
86     pointerEvent->SetPressedKeys(pressedKeys);
87     SimulateInputEventUtilTest(pointerEvent);
88 }
89 
90 /**
91  * @tc.name: PointerEventTest_keyEventAndPointerEvent_002
92  * @tc.desc: Verify ctrl(right) + point event
93  * @tc.type: FUNC
94  * @tc.require: AR000GOACS
95  * @tc.author: yangguang
96  */
97 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_002, TestSize.Level1)
98 {
99     CALL_TEST_DEBUG;
100     std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
101     ASSERT_TRUE(pointerEvent != nullptr);
102     std::vector<int32_t> pressedKeys { KeyEvent::KEYCODE_CTRL_RIGHT };
103     pointerEvent->SetPressedKeys(pressedKeys);
104     SimulateInputEventUtilTest(pointerEvent);
105 }
106 
107 /**
108  * @tc.name: PointerEventTest_keyEventAndPointerEvent_003
109  * @tc.desc: Verify ctrl(left and right) + point event
110  * @tc.type: FUNC
111  * @tc.require: AR000GOACS
112  * @tc.author: yangguang
113  */
114 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_003, TestSize.Level1)
115 {
116     CALL_TEST_DEBUG;
117     std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
118     ASSERT_TRUE(pointerEvent != nullptr);
119     std::vector<int32_t> pressedKeys { KeyEvent::KEYCODE_CTRL_LEFT, KeyEvent::KEYCODE_CTRL_RIGHT };
120     pointerEvent->SetPressedKeys(pressedKeys);
121     SimulateInputEventUtilTest(pointerEvent);
122 }
123 #endif // OHOS_BUILD_ENABLE_POINTER
124 
125 /**
126  * @tc.name: PointerEventTest_CheckMousePointEvent_001
127  * @tc.desc: Verify mouse point event
128  * @tc.type: FUNC
129  * @tc.require:
130  */
131 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_001, TestSize.Level1)
132 {
133     CALL_TEST_DEBUG;
134     auto pointerEvent = PointerEvent::Create();
135     ASSERT_NE(pointerEvent, nullptr);
136     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
137     ASSERT_TRUE(!pointerEvent->IsValid());
138 
139     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
140     pointerEvent->SetPointerId(-1);
141     ASSERT_TRUE(!pointerEvent->IsValid());
142 
143     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
144     pointerEvent->SetPointerId(0);
145     PointerEvent::PointerItem item1;
146     item1.SetPointerId(0);
147     pointerEvent->AddPointerItem(item1);
148     PointerEvent::PointerItem item2;
149     item2.SetPointerId(0);
150     pointerEvent->AddPointerItem(item2);
151     ASSERT_TRUE(!pointerEvent->IsValid());
152     PointerEvent::PointerItem item3;
153     item3.SetPointerId(0);
154     pointerEvent->AddPointerItem(item3);
155     PointerEvent::PointerItem item4;
156     item4.SetPointerId(0);
157     pointerEvent->AddPointerItem(item4);
158     PointerEvent::PointerItem item5;
159     item5.SetPointerId(0);
160     pointerEvent->AddPointerItem(item5);
161     PointerEvent::PointerItem item6;
162     item6.SetPointerId(0);
163     pointerEvent->AddPointerItem(item6);
164 
165     auto pointerEvent1 = PointerEvent::Create();
166     ASSERT_NE(pointerEvent1, nullptr);
167     pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
168     pointerEvent1->SetPointerId(0);
169     pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
170     pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
171     pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_RIGHT);
172     pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_MIDDLE);
173     item1.SetPointerId(0);
174     pointerEvent1->AddPointerItem(item1);
175     ASSERT_TRUE(!pointerEvent1->IsValid());
176 }
177 
178 /**
179  * @tc.name: PointerEventTest_CheckMousePointEvent_002
180  * @tc.desc: Verify mouse point event
181  * @tc.type: FUNC
182  * @tc.require:
183  */
184 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_002, TestSize.Level1)
185 {
186     CALL_TEST_DEBUG;
187     auto pointerEvent1 = PointerEvent::Create();
188     ASSERT_NE(pointerEvent1, nullptr);
189     pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
190     pointerEvent1->SetPointerId(0);
191     pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
192     PointerEvent::PointerItem item;
193     item.SetPointerId(0);
194     pointerEvent1->AddPointerItem(item);
195     ASSERT_TRUE(!pointerEvent1->IsValid());
196 
197     auto pointerEvent2 = PointerEvent::Create();
198     ASSERT_NE(pointerEvent2, nullptr);
199     pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
200     pointerEvent2->SetPointerId(0);
201     pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
202     pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
203     item.SetPointerId(0);
204     pointerEvent2->AddPointerItem(item);
205     ASSERT_TRUE(!pointerEvent2->IsValid());
206 
207     auto pointerEvent3 = PointerEvent::Create();
208     ASSERT_NE(pointerEvent3, nullptr);
209     pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
210     pointerEvent3->SetPointerId(0);
211     pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
212     pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
213     pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
214     item.SetPointerId(0);
215     pointerEvent3->AddPointerItem(item);
216     ASSERT_TRUE(!pointerEvent3->IsValid());
217 }
218 
219 /**
220  * @tc.name: PointerEventTest_CheckMousePointEvent_003
221  * @tc.desc: Verify mouse point event
222  * @tc.type: FUNC
223  * @tc.require:
224  */
225 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_003, TestSize.Level1)
226 {
227     CALL_TEST_DEBUG;
228     auto pointerEvent1 = PointerEvent::Create();
229     ASSERT_NE(pointerEvent1, nullptr);
230     pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
231     pointerEvent1->SetPointerId(0);
232     pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
233     pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
234     pointerEvent1->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
235     PointerEvent::PointerItem item;
236     item.SetPointerId(0);
237     pointerEvent1->AddPointerItem(item);
238     ASSERT_TRUE(!pointerEvent1->IsValid());
239 
240     auto pointerEvent2 = PointerEvent::Create();
241     ASSERT_NE(pointerEvent2, nullptr);
242     pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
243     pointerEvent2->SetPointerId(0);
244     pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
245     pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
246     pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
247     item.SetPointerId(-1);
248     pointerEvent2->AddPointerItem(item);
249     ASSERT_TRUE(!pointerEvent2->IsValid());
250 }
251 
252 /**
253  * @tc.name: PointerEventTest_CheckMousePointEvent_004
254  * @tc.desc: Verify mouse point event
255  * @tc.type: FUNC
256  * @tc.require:
257  */
258 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_004, TestSize.Level1)
259 {
260     CALL_TEST_DEBUG;
261     auto pointerEvent1 = PointerEvent::Create();
262     ASSERT_NE(pointerEvent1, nullptr);
263     pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
264     pointerEvent1->SetPointerId(0);
265     pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
266     pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
267     pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
268     PointerEvent::PointerItem item;
269     item.SetPointerId(2);
270     pointerEvent1->AddPointerItem(item);
271     ASSERT_TRUE(!pointerEvent1->IsValid());
272 
273     auto pointerEvent2 = PointerEvent::Create();
274     ASSERT_NE(pointerEvent2, nullptr);
275     pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
276     pointerEvent2->SetPointerId(0);
277     pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
278     pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
279     pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
280     item.SetPointerId(0);
281     item.SetDownTime(10010);
282     pointerEvent2->AddPointerItem(item);
283     ASSERT_TRUE(!pointerEvent2->IsValid());
284 
285     auto pointerEvent3 = PointerEvent::Create();
286     ASSERT_NE(pointerEvent3, nullptr);
287     pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
288     pointerEvent3->SetPointerId(0);
289     pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
290     pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
291     pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
292     item.SetPointerId(0);
293     item.SetDownTime(0);
294     item.SetPressed(true);
295     pointerEvent3->AddPointerItem(item);
296     ASSERT_TRUE(!pointerEvent3->IsValid());
297 }
298 
299 /**
300  * @tc.name: PointerEventTest_CheckMousePointEvent_005
301  * @tc.desc: Verify mouse point event
302  * @tc.type: FUNC
303  * @tc.require:
304  */
305 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_005, TestSize.Level1)
306 {
307     CALL_TEST_DEBUG;
308     auto pointerEvent = PointerEvent::Create();
309     ASSERT_NE(pointerEvent, nullptr);
310     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
311     pointerEvent->SetPointerId(0);
312     pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
313     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
314     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
315     PointerEvent::PointerItem item;
316     item.SetPointerId(0);
317     item.SetDownTime(0);
318     item.SetPressed(false);
319     pointerEvent->AddPointerItem(item);
320     ASSERT_TRUE(pointerEvent->IsValid());
321 }
322 
323 /**
324  * @tc.name: PointerEventTest_CheckMousePointEvent_006
325  * @tc.desc: Verify mouse point event
326  * @tc.type: FUNC
327  * @tc.require:
328  */
329 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_006, TestSize.Level1)
330 {
331     CALL_TEST_DEBUG;
332     auto inputEvent = InputEvent::Create();
333     ASSERT_NE(inputEvent, nullptr);
334     inputEvent->SetDeviceId(1);
335     inputEvent->SetTargetWindowId(1);
336     inputEvent->SetAgentWindowId(1);
337     auto event = PointerEvent::from(inputEvent);
338     ASSERT_EQ(event, nullptr);
339 
340     auto pointerEvent = PointerEvent::Create();
341     ASSERT_NE(pointerEvent, nullptr);
342     pointerEvent->Reset();
343     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
344     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
345     pointerEvent->SetPointerId(0);
346     pointerEvent->SetDeviceId(inputEvent->GetDeviceId());
347     pointerEvent->SetTargetWindowId(inputEvent->GetTargetWindowId());
348     pointerEvent->SetAgentWindowId(inputEvent->GetAgentWindowId());
349     PointerEvent::PointerItem item1;
350     item1.SetPointerId(0);
351     item1.SetDownTime(0);
352     item1.SetPressed(true);
353     item1.SetWindowX(10);
354     item1.SetWindowY(10);
355     item1.SetDeviceId(inputEvent->GetDeviceId());
356     item1.SetRawDx(60);
357     item1.SetRawDy(60);
358     pointerEvent->AddPointerItem(item1);
359     PointerEvent::PointerItem item2;
360     item2.SetPointerId(1);
361     item2.SetDownTime(0);
362     item2.SetPressed(false);
363     item2.SetWindowX(item1.GetWindowX());
364     item2.SetWindowY(item1.GetWindowY());
365     item2.SetDeviceId(inputEvent->GetDeviceId());
366     item2.SetRawDx(100);
367     item2.SetRawDy(100);
368     pointerEvent->AddPointerItem(item2);
369     ASSERT_TRUE(pointerEvent != nullptr);
370 #ifdef OHOS_BUILD_ENABLE_POINTER
371     SimulateInputEventUtilTest(pointerEvent);
372 #endif // OHOS_BUILD_ENABLE_POINTER
373 }
374 
375 /**
376  * @tc.name: PointerEventTest_CheckTouchPointEvent_001
377  * @tc.desc: Verify touch screen event
378  * @tc.type: FUNC
379  * @tc.require:
380  */
381 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_001, TestSize.Level1)
382 {
383     CALL_TEST_DEBUG;
384     auto pointerEvent = PointerEvent::Create();
385     ASSERT_NE(pointerEvent, nullptr);
386     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
387     pointerEvent->SetPointerId(-1);
388     ASSERT_TRUE(!pointerEvent->IsValid());
389 
390     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
391     pointerEvent->SetPointerId(0);
392     pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
393     ASSERT_TRUE(!pointerEvent->IsValid());
394 
395     auto pointerEvent1 = PointerEvent::Create();
396     ASSERT_NE(pointerEvent1, nullptr);
397     pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
398     pointerEvent1->SetPointerId(0);
399     pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
400     ASSERT_TRUE(!pointerEvent1->IsValid());
401 
402     auto pointerEvent2 = PointerEvent::Create();
403     ASSERT_NE(pointerEvent2, nullptr);
404     pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
405     pointerEvent2->SetPointerId(0);
406     pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
407     pointerEvent2->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
408     ASSERT_TRUE(!pointerEvent2->IsValid());
409 }
410 
411 /**
412  * @tc.name: PointerEventTest_CheckTouchPointEvent_002
413  * @tc.desc: Verify touch screen event
414  * @tc.type: FUNC
415  * @tc.require:
416  */
417 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_002, TestSize.Level1)
418 {
419     CALL_TEST_DEBUG;
420     auto pointerEvent1 = PointerEvent::Create();
421     ASSERT_NE(pointerEvent1, nullptr);
422     pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
423     pointerEvent1->SetPointerId(0);
424     pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
425     pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
426     PointerEvent::PointerItem item;
427     item.SetPointerId(-1);
428     pointerEvent1->AddPointerItem(item);
429     ASSERT_TRUE(!pointerEvent1->IsValid());
430 
431     auto pointerEvent2 = PointerEvent::Create();
432     ASSERT_NE(pointerEvent2, nullptr);
433     pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
434     pointerEvent2->SetPointerId(0);
435     pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
436     pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
437     item.SetPointerId(0);
438     item.SetDownTime(0);
439     item.SetPressed(false);
440     pointerEvent2->AddPointerItem(item);
441     ASSERT_TRUE(!pointerEvent2->IsValid());
442 }
443 
444 /**
445  * @tc.name: PointerEventTest_CheckTouchPointEvent_003
446  * @tc.desc: Verify touch screen event
447  * @tc.type: FUNC
448  * @tc.require:
449  */
450 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_003, TestSize.Level1)
451 {
452     CALL_TEST_DEBUG;
453     auto pointerEvent1 = PointerEvent::Create();
454     ASSERT_NE(pointerEvent1, nullptr);
455     pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
456     pointerEvent1->SetPointerId(0);
457     pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
458     pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
459     PointerEvent::PointerItem item;
460     item.SetPointerId(0);
461     item.SetDownTime(100);
462     item.SetPressed(true);
463     pointerEvent1->AddPointerItem(item);
464     ASSERT_TRUE(!pointerEvent1->IsValid());
465 
466     auto pointerEvent2 = PointerEvent::Create();
467     ASSERT_NE(pointerEvent2, nullptr);
468     pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
469     pointerEvent2->SetPointerId(0);
470     pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
471     pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
472     PointerEvent::PointerItem item1;
473     item1.SetPointerId(0);
474     item1.SetDownTime(100);
475     item1.SetPressed(false);
476     pointerEvent2->AddPointerItem(item1);
477     PointerEvent::PointerItem item2;
478     item2.SetPointerId(0);
479     item2.SetDownTime(100);
480     item2.SetPressed(false);
481     pointerEvent2->AddPointerItem(item2);
482     ASSERT_FALSE(!pointerEvent2->IsValid());
483 }
484 
485 /**
486  * @tc.name: PointerEventTest_CheckTouchPointEvent_004
487  * @tc.desc: Verify touch screen event
488  * @tc.type: FUNC
489  * @tc.require:
490  */
491 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_004, TestSize.Level1)
492 {
493     CALL_TEST_DEBUG;
494     auto pointerEvent = PointerEvent::Create();
495     ASSERT_NE(pointerEvent, nullptr);
496     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
497     pointerEvent->SetPointerId(0);
498     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
499     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
500     PointerEvent::PointerItem item1;
501     item1.SetPointerId(1);
502     item1.SetDownTime(100);
503     item1.SetPressed(false);
504     pointerEvent->AddPointerItem(item1);
505     PointerEvent::PointerItem item2;
506     item2.SetPointerId(2);
507     item2.SetDownTime(100);
508     item2.SetPressed(false);
509     pointerEvent->AddPointerItem(item2);
510     ASSERT_TRUE(!pointerEvent->IsValid());
511 }
512 
513 /**
514  * @tc.name: PointerEventTest_CheckTouchPointEvent_005
515  * @tc.desc: Verify touch screen event
516  * @tc.type: FUNC
517  * @tc.require:
518  */
519 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_005, TestSize.Level1)
520 {
521     CALL_TEST_DEBUG;
522     auto pointerEvent = PointerEvent::Create();
523     ASSERT_NE(pointerEvent, nullptr);
524     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
525     pointerEvent->SetPointerId(0);
526     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
527     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
528     PointerEvent::PointerItem item1;
529     item1.SetPointerId(0);
530     item1.SetDownTime(100);
531     item1.SetPressed(false);
532     pointerEvent->AddPointerItem(item1);
533     PointerEvent::PointerItem item2;
534     item2.SetPointerId(1);
535     item2.SetDownTime(100);
536     item2.SetPressed(false);
537     pointerEvent->AddPointerItem(item2);
538     ASSERT_TRUE(pointerEvent->IsValid());
539 }
540 
541 /**
542  * @tc.name: PointerEventTest_CheckTouchPointEvent_006
543  * @tc.desc: Verify touch screen event
544  * @tc.type: FUNC
545  * @tc.require: I5QSN3
546  */
547 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_006, TestSize.Level1)
548 {
549     CALL_TEST_DEBUG;
550     auto pointerEvent = PointerEvent::Create();
551     ASSERT_NE(pointerEvent, nullptr);
552     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
553     pointerEvent->SetPointerId(0);
554     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
555     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
556     PointerEvent::PointerItem item;
557     item.SetPointerId(0);
558     item.SetDownTime(100);
559     item.SetToolDisplayX(90);
560     item.SetToolDisplayY(90);
561     item.SetToolWindowX(50);
562     item.SetToolWindowY(50);
563     item.SetToolWidth(30);
564     item.SetToolHeight(30);
565     item.SetLongAxis(100);
566     item.SetShortAxis(20);
567     item.SetToolType(2);
568     item.SetTargetWindowId(0);
569     pointerEvent->AddPointerItem(item);
570     ASSERT_TRUE(pointerEvent->IsValid());
571     DumpWindowData(pointerEvent);
572     pointerEvent->RemovePointerItem(0);
573     pointerEvent->IsButtonPressed(0);
574     pointerEvent->ClearButtonPressed();
575     pointerEvent->ClearAxisValue();
576     pointerEvent->DeleteReleaseButton(PointerEvent::BUTTON_NONE);
577     ASSERT_FALSE(pointerEvent->IsValid());
578 }
579 
580 /**
581  * @tc.name: PointerEventTest_CheckTouchInputEvent_001
582  * @tc.desc: Verify touch screen event
583  * @tc.type: FUNC
584  * @tc.require: I5QSN3
585  */
586 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchInputEvent_001, TestSize.Level1)
587 {
588     CALL_TEST_DEBUG;
589     auto inputEvent = InputEvent::Create();
590     ASSERT_NE(inputEvent, nullptr);
591     inputEvent->SetTargetDisplayId(0);
592     inputEvent->SetDeviceId(0);
593     inputEvent->EventTypeToString(InputEvent::EVENT_TYPE_POINTER);
594     inputEvent->HasFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
595     inputEvent->ClearFlag();
596 }
597 
598 /**
599  * @tc.name: PointerEventTest_SetEnhanceData_001
600  * @tc.desc: Set the enhance data.
601  * @tc.type: FUNC
602  * @tc.require:
603  */
604 HWTEST_F(PointerEventTest, PointerEventTest_SetEnhanceData_001, TestSize.Level1)
605 {
606     CALL_TEST_DEBUG;
607     auto pointerEvent = PointerEvent::Create();
608     ASSERT_NE(pointerEvent, nullptr);
609     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
610     pointerEvent->SetPointerId(0);
611     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
612     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
613     PointerEvent::PointerItem item;
614     item.SetPointerId(-1);
615     pointerEvent->AddPointerItem(item);
616     uint32_t enHanceDataLen = 3;
617     uint8_t enhanceDataBuf[enHanceDataLen];
618     std::vector<uint8_t> enhanceData;
619     for (uint32_t i = 0; i < enHanceDataLen; i++) {
620         enhanceData.push_back(enhanceDataBuf[i]);
621     }
622     #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
623     ASSERT_NO_FATAL_FAILURE(pointerEvent->SetEnhanceData(enhanceData));
624     ASSERT_EQ(pointerEvent->GetEnhanceData(), enhanceData);
625     #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
626 }
627 
628 /**
629  * @tc.name: PointerEventTest_SetToolDisplayX_001
630  * @tc.desc: Set Tool Display Coordinates.
631  * @tc.type: FUNC
632  * @tc.require:
633  */
634 HWTEST_F(PointerEventTest, PointerEventTest_SetToolDisplayX_001, TestSize.Level1)
635 {
636     CALL_TEST_DEBUG;
637     auto pointerEvent = PointerEvent::Create();
638     ASSERT_NE(pointerEvent, nullptr);
639     int32_t displayX = 90;
640     PointerEvent::PointerItem item;
641     item.SetPointerId(1);
642     item.SetDownTime(0);
643     ASSERT_NO_FATAL_FAILURE(item.SetToolDisplayX(displayX));
644     ASSERT_EQ(item.GetToolDisplayX(), displayX);
645     pointerEvent->AddPointerItem(item);
646 }
647 
648 /**
649  * @tc.name: PointerEventTest_SetToolDisplayY_001
650  * @tc.desc: Set Tool Display Coordinates.
651  * @tc.type: FUNC
652  * @tc.require:
653  */
654 HWTEST_F(PointerEventTest, PointerEventTest_SetToolDisplayY_001, TestSize.Level1)
655 {
656     CALL_TEST_DEBUG;
657     auto pointerEvent = PointerEvent::Create();
658     ASSERT_NE(pointerEvent, nullptr);
659     int32_t displayY = 70;
660     PointerEvent::PointerItem item;
661     item.SetPointerId(2);
662     item.SetDownTime(1);
663     ASSERT_NO_FATAL_FAILURE(item.SetToolDisplayY(displayY));
664     ASSERT_EQ(item.GetToolDisplayY(), displayY);
665     pointerEvent->AddPointerItem(item);
666 }
667 
668 /**
669  * @tc.name: PointerEventTest_SetToolWidth_001
670  * @tc.desc: Set Tool Display Width.
671  * @tc.type: FUNC
672  * @tc.require:
673  */
674 HWTEST_F(PointerEventTest, PointerEventTest_SetToolWidth_001, TestSize.Level1)
675 {
676     CALL_TEST_DEBUG;
677     int32_t toolWidth = 30;
678     PointerEvent::PointerItem item;
679     item.SetPointerId(3);
680     item.SetDownTime(0);
681     ASSERT_NO_FATAL_FAILURE(item.SetToolWidth(toolWidth));
682     ASSERT_EQ(item.GetToolWidth(), toolWidth);
683 }
684 
685 /**
686  * @tc.name: PointerEventTest_SetToolHeight_001
687  * @tc.desc: Set Tool Display Height.
688  * @tc.type: FUNC
689  * @tc.require:
690  */
691 HWTEST_F(PointerEventTest, PointerEventTest_SetToolHeight_001, TestSize.Level1)
692 {
693     CALL_TEST_DEBUG;
694     int32_t toolHeight = 40;
695     PointerEvent::PointerItem item;
696     item.SetPointerId(4);
697     item.SetDownTime(1);
698     ASSERT_NO_FATAL_FAILURE(item.SetToolHeight(toolHeight));
699     ASSERT_EQ(item.GetToolHeight(), toolHeight);
700 }
701 
702 /**
703  * @tc.name: PointerEventTest_SetLongAxis_001
704  * @tc.desc: Sets the long axis of the touch point area.
705  * @tc.type: FUNC
706  * @tc.require:
707  */
708 HWTEST_F(PointerEventTest, PointerEventTest_SetLongAxis_001, TestSize.Level1)
709 {
710     CALL_TEST_DEBUG;
711     int32_t longAxis = 50;
712     PointerEvent::PointerItem item;
713     item.SetPointerId(5);
714     item.SetDownTime(0);
715     ASSERT_NO_FATAL_FAILURE(item.SetLongAxis(longAxis));
716     ASSERT_EQ(item.GetLongAxis(), longAxis);
717 }
718 
719 /**
720  * @tc.name: PointerEventTest_SetShortAxis_001
721  * @tc.desc: Sets the short axis of the touch point area.
722  * @tc.type: FUNC
723  * @tc.require:
724  */
725 HWTEST_F(PointerEventTest, PointerEventTest_SetShortAxis_001, TestSize.Level1)
726 {
727     CALL_TEST_DEBUG;
728     int32_t shortAxis = 45;
729     PointerEvent::PointerItem item;
730     item.SetPointerId(6);
731     item.SetDownTime(1);
732     ASSERT_NO_FATAL_FAILURE(item.SetShortAxis(shortAxis));
733     ASSERT_EQ(item.GetShortAxis(), shortAxis);
734 }
735 
736 /**
737  * @tc.name: PointerEventTest_GetPointerCount_001
738  * @tc.desc: Get pointer count
739  * @tc.type: FUNC
740  * @tc.require:
741  */
742 HWTEST_F(PointerEventTest, PointerEventTest_GetPointerCount_001, TestSize.Level1)
743 {
744     CALL_TEST_DEBUG;
745     auto pointerEvent = PointerEvent::Create();
746     int32_t pointerCount = pointerEvent->GetPointerCount();
747     ASSERT_EQ(pointerCount, 0);
748 }
749 
750 /**
751  * @tc.name: PointerEventTest_SetExtraData_001
752  * @tc.desc: Set extra data
753  * @tc.type: FUNC
754  * @tc.require:
755  */
756 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_001, TestSize.Level1)
757 {
758     CALL_TEST_DEBUG;
759     const uint32_t length = 5;
760     std::shared_ptr<const uint8_t[]> data;
761     auto inputEvent = InputEvent::Create();
762     ASSERT_NE(inputEvent, nullptr);
763     inputEvent->SetExtraData(data, length);
764 }
765 
766 /**
767  * @tc.name: PointerEventTest_GetExtraData_001
768  * @tc.desc: Get extra data
769  * @tc.type: FUNC
770  * @tc.require:
771  */
772 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_001, TestSize.Level1)
773 {
774     CALL_TEST_DEBUG;
775     auto inputEvent = InputEvent::Create();
776     std::shared_ptr<const uint8_t[]> retrievedData;
777     uint32_t retrievedLength;
778     inputEvent->GetExtraData(retrievedData, retrievedLength);
779 }
780 
781 /**
782  * @tc.name: PointerEventTest_SetRawDx_001
783  * @tc.desc: Sets the raw X coordinate.
784  * @tc.type: FUNC
785  * @tc.require:
786  */
787 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDx_001, TestSize.Level1)
788 {
789     CALL_TEST_DEBUG;
790     int32_t rawDx = 55;
791     PointerEvent::PointerItem item;
792     item.SetPointerId(7);
793     item.SetDownTime(0);
794     ASSERT_NO_FATAL_FAILURE(item.SetRawDx(rawDx));
795     ASSERT_EQ(item.GetRawDx(), rawDx);
796 }
797 
798 /**
799  * @tc.name: PointerEventTest_SetRawDy_001
800  * @tc.desc: Sets the raw Y coordinate.
801  * @tc.type: FUNC
802  * @tc.require:
803  */
804 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDy_001, TestSize.Level1)
805 {
806     CALL_TEST_DEBUG;
807     int32_t rawDy = 60;
808     PointerEvent::PointerItem item;
809     item.SetPointerId(8);
810     item.SetDownTime(1);
811     ASSERT_NO_FATAL_FAILURE(item.SetRawDy(rawDy));
812     ASSERT_EQ(item.GetRawDy(), rawDy);
813 }
814 
815 /**
816  * @tc.name: PointerEventTest_ClearFlag_001
817  * @tc.desc: Clears all flags of an input event.
818  * @tc.type: FUNC
819  * @tc.require:
820  */
821 HWTEST_F(PointerEventTest, PointerEventTest_ClearFlag_001, TestSize.Level1)
822 {
823     CALL_TEST_DEBUG;
824     auto inputEvent = InputEvent::Create();
825     ASSERT_NE(inputEvent, nullptr);
826     inputEvent->SetTargetDisplayId(0);
827     inputEvent->SetDeviceId(0);
828     inputEvent->EventTypeToString(InputEvent::EVENT_TYPE_POINTER);
829     inputEvent->AddFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
830     ASSERT_NO_FATAL_FAILURE(inputEvent->ClearFlag());
831     ASSERT_EQ(inputEvent->GetFlag(), InputEvent::EVENT_FLAG_NONE);
832 }
833 
834 /**
835  * @tc.name: PointerEventTest_From_001
836  * @tc.desc: Convert InputEvent to nullptr.
837  * @tc.type: FUNC
838  * @tc.require:
839  */
840 HWTEST_F(PointerEventTest, PointerEventTest_From_001, TestSize.Level1)
841 {
842     CALL_TEST_DEBUG;
843     auto inputEvent = InputEvent::Create();
844     ASSERT_NE(inputEvent, nullptr);
845     inputEvent->SetDeviceId(2);
846     inputEvent->SetTargetWindowId(2);
847     inputEvent->SetAgentWindowId(2);
848     auto event = PointerEvent::from(inputEvent);
849     ASSERT_EQ(event, nullptr);
850 }
851 
852 /**
853  * @tc.name: PointerEventTest_Reset_001
854  * @tc.desc: Reset pointer event.
855  * @tc.type: FUNC
856  * @tc.require:
857  */
858 HWTEST_F(PointerEventTest, PointerEventTest_Reset_001, TestSize.Level1)
859 {
860     CALL_TEST_DEBUG;
861     auto pointerEvent = PointerEvent::Create();
862     ASSERT_NE(pointerEvent, nullptr);
863     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
864     pointerEvent->SetPointerId(1);
865     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
866     ASSERT_NO_FATAL_FAILURE(pointerEvent->Reset());
867     ASSERT_EQ(pointerEvent->GetSourceType(), PointerEvent::SOURCE_TYPE_UNKNOWN);
868     ASSERT_EQ(pointerEvent->GetPointerId(), -1);
869     ASSERT_EQ(pointerEvent->GetPointerAction(), PointerEvent::POINTER_ACTION_UNKNOWN);
870 }
871 
872 /**
873  * @tc.name: PointerEventTest_IsButtonPressed_001
874  * @tc.desc: Determine whether the button is pressed.
875  * @tc.type: FUNC
876  * @tc.require:
877  */
878 HWTEST_F(PointerEventTest, PointerEventTest_IsButtonPressed_001, TestSize.Level1)
879 {
880     CALL_TEST_DEBUG;
881     auto pointerEvent = PointerEvent::Create();
882     ASSERT_NE(pointerEvent, nullptr);
883     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
884     pointerEvent->SetPointerId(0);
885     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
886     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
887     pointerEvent->SetButtonPressed(0);
888     ASSERT_TRUE(pointerEvent->IsButtonPressed(0));
889 }
890 
891 /**
892  * @tc.name: PointerEventTest_DeleteReleaseButton_001
893  * @tc.desc: Deletes a released button.
894  * @tc.type: FUNC
895  * @tc.require:
896  */
897 HWTEST_F(PointerEventTest, PointerEventTest_DeleteReleaseButton_001, TestSize.Level1)
898 {
899     CALL_TEST_DEBUG;
900     auto pointerEvent = PointerEvent::Create();
901     ASSERT_NE(pointerEvent, nullptr);
902     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
903     pointerEvent->SetPointerId(0);
904     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
905     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
906     pointerEvent->SetButtonPressed(0);
907     ASSERT_NO_FATAL_FAILURE(pointerEvent->DeleteReleaseButton(0));
908     std::set<int32_t> pressButtons = pointerEvent->GetPressedButtons();
909     ASSERT_EQ(pressButtons.size(), 0);
910 }
911 
912 /**
913  * @tc.name: PointerEventTest_ClearButtonPressed_001
914  * @tc.desc: Clears the button in the pressed state.
915  * @tc.type: FUNC
916  * @tc.require:
917  */
918 HWTEST_F(PointerEventTest, PointerEventTest_ClearButtonPressed_001, TestSize.Level1)
919 {
920     CALL_TEST_DEBUG;
921     auto pointerEvent = PointerEvent::Create();
922     ASSERT_NE(pointerEvent, nullptr);
923     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
924     pointerEvent->SetPointerId(0);
925     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
926     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
927     pointerEvent->SetButtonPressed(0);
928     ASSERT_NO_FATAL_FAILURE(pointerEvent->ClearButtonPressed());
929     std::set<int32_t> pressButtons = pointerEvent->GetPressedButtons();
930     ASSERT_EQ(pressButtons.size(), 0);
931 }
932 
933 /**
934  * @tc.name: PointerEventTest_ClearAxisValue_001
935  * @tc.desc: Clears the button in the pressed state.
936  * @tc.type: FUNC
937  * @tc.require:
938  */
939 HWTEST_F(PointerEventTest, PointerEventTest_ClearAxisValue_001, TestSize.Level1)
940 {
941     CALL_TEST_DEBUG;
942     auto pointerEvent = PointerEvent::Create();
943     ASSERT_NE(pointerEvent, nullptr);
944     pointerEvent->SetPointerId(0);
945     pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, 30.0);
946     double axisValue = pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL);
947     ASSERT_EQ(axisValue, 30.0);
948     ASSERT_NO_FATAL_FAILURE(pointerEvent->ClearAxisValue());
949     ASSERT_EQ(pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL), 0);
950 }
951 
952 /**
953  * @tc.name: PointerEventTest_SetZorderValue_001
954  * @tc.desc: Sets the zOrder for this event, inject to windows whose zOrder less than the target zOrder.
955  * @tc.type: FUNC
956  * @tc.require:
957  */
958 HWTEST_F(PointerEventTest, PointerEventTest_SetZorderValue_001, TestSize.Level1)
959 {
960     CALL_TEST_DEBUG;
961     auto pointerEvent = PointerEvent::Create();
962     ASSERT_NE(pointerEvent, nullptr);
963     pointerEvent->SetPointerId(0);
964     pointerEvent->SetZOrder(30.0);
965     float zOrder = pointerEvent->GetZOrder();
966     ASSERT_EQ(zOrder, 30.0);
967 }
968 
969 /**
970  * @tc.name: PointerEventTest_IsValid_001
971  * @tc.desc: Checks whether this input event is valid.
972  * @tc.type: FUNC
973  * @tc.require:
974  */
975 HWTEST_F(PointerEventTest, PointerEventTest_IsValid_001, TestSize.Level1)
976 {
977     CALL_TEST_DEBUG;
978     auto pointerEvent = PointerEvent::Create();
979     ASSERT_NE(pointerEvent, nullptr);
980     pointerEvent->SetPointerId(0);
981     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
982     ASSERT_FALSE(pointerEvent->IsValid());
983     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
984     ASSERT_FALSE(pointerEvent->IsValid());
985     pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
986     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
987     pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
988     PointerEvent::PointerItem item;
989     item.SetPointerId(0);
990     item.SetDownTime(0);
991     item.SetPressed(false);
992     pointerEvent->AddPointerItem(item);
993     ASSERT_TRUE(pointerEvent->IsValid());
994 }
995 
996 /**
997  * @tc.name: PointerEventTest_GetFingerCount_001
998  * @tc.desc: Sets the fingerCount for this event.
999  * @tc.type: FUNC
1000  * @tc.require:
1001  */
1002 HWTEST_F(PointerEventTest, PointerEventTest_GetFingerCount_001, TestSize.Level1)
1003 {
1004     CALL_TEST_DEBUG;
1005     auto pointerEvent = PointerEvent::Create();
1006     ASSERT_NE(pointerEvent, nullptr);
1007     pointerEvent->SetFingerCount(-12);
1008     int32_t fingerCount = pointerEvent->GetFingerCount();
1009     ASSERT_EQ(fingerCount, -12);
1010     pointerEvent->SetFingerCount(-6);
1011     fingerCount = pointerEvent->GetFingerCount();
1012     ASSERT_EQ(fingerCount, -6);
1013     pointerEvent->SetFingerCount(0);
1014     fingerCount = pointerEvent->GetFingerCount();
1015     ASSERT_EQ(fingerCount, 0);
1016     pointerEvent->SetFingerCount(6);
1017     fingerCount = pointerEvent->GetFingerCount();
1018     ASSERT_EQ(fingerCount, 6);
1019     pointerEvent->SetFingerCount(12);
1020     fingerCount = pointerEvent->GetFingerCount();
1021     ASSERT_EQ(fingerCount, 12);
1022 }
1023 
1024 /**
1025  * @tc.name: PointerEventTest_ClearBuffer_001
1026  * @tc.desc: Clear the buffer data.
1027  * @tc.type: FUNC
1028  * @tc.require:
1029  */
1030 HWTEST_F(PointerEventTest, PointerEventTest_ClearBuffer_001, TestSize.Level1)
1031 {
1032     CALL_TEST_DEBUG;
1033     auto pointerEvent = PointerEvent::Create();
1034     ASSERT_NE(pointerEvent, nullptr);
1035     uint32_t enHanceDataLen = 3;
1036     uint8_t enhanceDataBuf[enHanceDataLen];
1037     std::vector<uint8_t> enhanceData;
1038     for (uint32_t i = 0; i < enHanceDataLen; i++) {
1039         enhanceData.push_back(enhanceDataBuf[i]);
1040     }
1041     pointerEvent->SetBuffer(enhanceData);
1042     std::vector<uint8_t> buffer = pointerEvent->GetBuffer();
1043     ASSERT_NE(buffer.size(), 0);
1044     pointerEvent->ClearBuffer();
1045     buffer = pointerEvent->GetBuffer();
1046     ASSERT_EQ(buffer.size(), 0);
1047 }
1048 
1049 /**
1050  * @tc.name: PointerEventTest_SetOriginPointerId_001
1051  * @tc.desc: Sets the origin id of the pointer in this event.
1052  * @tc.type: FUNC
1053  * @tc.require:
1054  */
1055 HWTEST_F(PointerEventTest, PointerEventTest_SetOriginPointerId_001, TestSize.Level1)
1056 {
1057     CALL_TEST_DEBUG;
1058     int32_t originPointerId = 11;
1059     PointerEvent::PointerItem item;
1060     ASSERT_NO_FATAL_FAILURE(item.SetOriginPointerId(originPointerId));
1061     ASSERT_EQ(item.GetOriginPointerId(), originPointerId);
1062 }
1063 
1064 /**
1065  * @tc.name: PointerEventTest_SetDisplayXPos_001
1066  * @tc.desc: Sets the x coordinate relative to the upper left corner of the screen.
1067  * @tc.type: FUNC
1068  * @tc.require:
1069  */
1070 HWTEST_F(PointerEventTest, PointerEventTest_SetDisplayXPos_001, TestSize.Level1)
1071 {
1072     CALL_TEST_DEBUG;
1073     double displayX = 10.0;
1074     PointerEvent::PointerItem item;
1075     ASSERT_NO_FATAL_FAILURE(item.SetDisplayXPos(displayX));
1076     ASSERT_EQ(item.GetDisplayXPos(), displayX);
1077 }
1078 
1079 /**
1080  * @tc.name: PointerEventTest_SetDisplayYPos_001
1081  * @tc.desc: Sets the y coordinate relative to the upper left corner of the screen.
1082  * @tc.type: FUNC
1083  * @tc.require:
1084  */
1085 HWTEST_F(PointerEventTest, PointerEventTest_SetDisplayYPos_001, TestSize.Level1)
1086 {
1087     CALL_TEST_DEBUG;
1088     double displayY = 10.0;
1089     PointerEvent::PointerItem item;
1090     ASSERT_NO_FATAL_FAILURE(item.SetDisplayYPos(displayY));
1091     ASSERT_EQ(item.GetDisplayYPos(), displayY);
1092 }
1093 
1094 /**
1095  * @tc.name: PointerEventTest_SetWindowXPos_001
1096  * @tc.desc: Sets the x coordinate of the active window.
1097  * @tc.type: FUNC
1098  * @tc.require:
1099  */
1100 HWTEST_F(PointerEventTest, PointerEventTest_SetWindowXPos_001, TestSize.Level1)
1101 {
1102     CALL_TEST_DEBUG;
1103     double x = 10.0;
1104     PointerEvent::PointerItem item;
1105     ASSERT_NO_FATAL_FAILURE(item.SetWindowXPos(x));
1106     ASSERT_EQ(item.GetWindowXPos(), x);
1107 }
1108 
1109 /**
1110  * @tc.name: PointerEventTest_SetWindowYPos_001
1111  * @tc.desc: Sets the y coordinate of the active window.
1112  * @tc.type: FUNC
1113  * @tc.require:
1114  */
1115 HWTEST_F(PointerEventTest, PointerEventTest_SetWindowYPos_001, TestSize.Level1)
1116 {
1117     CALL_TEST_DEBUG;
1118     double y = 10.0;
1119     PointerEvent::PointerItem item;
1120     ASSERT_NO_FATAL_FAILURE(item.SetWindowYPos(y));
1121     ASSERT_EQ(item.GetWindowYPos(), y);
1122 }
1123 
1124 /**
1125  * @tc.name: PointerEventTest_ActionToShortStr_001
1126  * @tc.desc: Verify ActionToShortStr
1127  * @tc.type: FUNC
1128  * @tc.require:
1129  * @tc.author:
1130  */
1131 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_001, TestSize.Level1)
1132 {
1133     CALL_TEST_DEBUG;
1134     int32_t eventType = 1;
1135     AxisEvent axisevent(eventType);
1136     int32_t action = AxisEvent::AXIS_ACTION_CANCEL;
1137     auto ret = axisevent.ActionToShortStr(action);
1138     ASSERT_EQ(ret, "A:C:");
1139     action = AxisEvent::AXIS_ACTION_START;
1140     ret = axisevent.ActionToShortStr(action);
1141     ASSERT_EQ(ret, "A:S:");
1142     action = AxisEvent::AXIS_ACTION_UPDATE;
1143     ret = axisevent.ActionToShortStr(action);
1144     ASSERT_EQ(ret, "A:U:");
1145     action = AxisEvent::AXIS_ACTION_END;
1146     ret = axisevent.ActionToShortStr(action);
1147     ASSERT_EQ(ret, "A:E:");
1148     action = AxisEvent::AXIS_ACTION_UNKNOWN;
1149     ret = axisevent.ActionToShortStr(action);
1150     ASSERT_EQ(ret, "A:UK:");
1151     action = 10;
1152     ret = axisevent.ActionToShortStr(action);
1153     ASSERT_EQ(ret, "A:?:");
1154 }
1155 
1156 /**
1157  * @tc.name: PointerEventTest_AddCapability_001
1158  * @tc.desc: Verify AddCapability
1159  * @tc.type: FUNC
1160  * @tc.require:
1161  * @tc.author:
1162  */
1163 HWTEST_F(PointerEventTest, PointerEventTest_AddCapability_001, TestSize.Level1)
1164 {
1165     CALL_TEST_DEBUG;
1166     InputDevice device;
1167     InputDeviceCapability cap;
1168     cap = INPUT_DEV_CAP_TOUCH;
1169     ASSERT_NO_FATAL_FAILURE(device.AddCapability(cap));
1170     cap = INPUT_DEV_CAP_MAX;
1171     ASSERT_NO_FATAL_FAILURE(device.AddCapability(cap));
1172 }
1173 
1174 /**
1175  * @tc.name: PointerEventTest_HasCapability_001
1176  * @tc.desc: Verify HasCapability
1177  * @tc.type: FUNC
1178  * @tc.require:
1179  * @tc.author:
1180  */
1181 HWTEST_F(PointerEventTest, PointerEventTest_HasCapability_001, TestSize.Level1)
1182 {
1183     CALL_TEST_DEBUG;
1184     InputDevice device;
1185     InputDeviceCapability cap;
1186     cap = INPUT_DEV_CAP_TOUCH;
1187     bool ret = device.HasCapability(cap);
1188     ASSERT_FALSE(ret);
1189     cap = INPUT_DEV_CAP_MAX;
1190     ret = device.HasCapability(cap);
1191     ASSERT_FALSE(ret);
1192 }
1193 
1194 /**
1195  * @tc.name: PointerEventTest_HasCapability_002
1196  * @tc.desc: Verify HasCapability
1197  * @tc.type: FUNC
1198  * @tc.require:
1199  * @tc.author:
1200  */
1201 HWTEST_F(PointerEventTest, PointerEventTest_HasCapability_002, TestSize.Level1)
1202 {
1203     CALL_TEST_DEBUG;
1204     InputDevice device;
1205     device.capabilities_.set(InputDeviceCapability::INPUT_DEV_CAP_KEYBOARD);
1206     device.capabilities_.set(InputDeviceCapability::INPUT_DEV_CAP_POINTER);
1207     EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD));
1208     EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_POINTER));
1209     EXPECT_FALSE(device.HasCapability(INPUT_DEV_CAP_TOUCH));
1210     EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD | INPUT_DEV_CAP_POINTER | INPUT_DEV_CAP_TOUCH));
1211     EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD | INPUT_DEV_CAP_POINTER));
1212 }
1213 
1214 /**
1215  * @tc.name: PointerEventTest_MarkProcessed_001
1216  * @tc.desc: Verify MarkProcessed
1217  * @tc.type: FUNC
1218  * @tc.require:
1219  * @tc.author:
1220  */
1221 HWTEST_F(PointerEventTest, PointerEventTest_MarkProcessed_001, TestSize.Level1)
1222 {
1223     CALL_TEST_DEBUG;
1224     std::function<void(int32_t, int64_t)> processedCallback_;
1225     auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1226     inputEvent->markEnabled_ = true;
1227     ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1228     inputEvent->markEnabled_ = false;
1229     ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1230 }
1231 
1232 /**
1233  * @tc.name: PointerEventTest_SetExtraData_002
1234  * @tc.desc: Verify SetExtraData
1235  * @tc.type: FUNC
1236  * @tc.require:
1237  * @tc.author:
1238  */
1239 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_002, TestSize.Level1)
1240 {
1241     CALL_TEST_DEBUG;
1242     auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1243     std::shared_ptr<const uint8_t[]> data;
1244     uint32_t length = 10;
1245     ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(data, length));
1246 }
1247 
1248 /**
1249  * @tc.name: PointerEventTest_GetExtraData_002
1250  * @tc.desc: Verify GetExtraData
1251  * @tc.type: FUNC
1252  * @tc.require:
1253  * @tc.author:
1254  */
1255 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_002, TestSize.Level1)
1256 {
1257     CALL_TEST_DEBUG;
1258     auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1259     std::shared_ptr<const uint8_t[]> data;
1260     uint32_t length = 10;
1261     inputEvent->extraDataLength_ = 5;
1262     std::shared_ptr<const uint8_t[]> extraData;
1263     inputEvent->extraData_ = extraData;
1264     ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1265 }
1266 
1267 /**
1268  * @tc.name: PointerEventTest_WriteToParcel_001
1269  * @tc.desc: Verify WriteToParcel
1270  * @tc.type: FUNC
1271  * @tc.require:
1272  * @tc.author:
1273  */
1274 HWTEST_F(PointerEventTest, PointerEventTest_WriteToParcel_001, TestSize.Level1)
1275 {
1276     CALL_TEST_DEBUG;
1277     auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1278     Parcel out;
1279     inputEvent->extraDataLength_ = 5;
1280     std::shared_ptr<const uint8_t[]> extraData;
1281     inputEvent->extraData_ = extraData;
1282     bool ret = inputEvent->WriteToParcel(out);
1283     ASSERT_TRUE(ret);
1284 }
1285 
1286 /**
1287  * @tc.name: PointerEventTest_ReadFromParcel_001
1288  * @tc.desc: Verify ReadFromParcel
1289  * @tc.type: FUNC
1290  * @tc.require:
1291  * @tc.author:
1292  */
1293 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel_001, TestSize.Level1)
1294 {
1295     CALL_TEST_DEBUG;
1296     auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1297     Parcel in;
1298     inputEvent->extraDataLength_ = 1088;
1299     bool ret = inputEvent->ReadFromParcel(in);
1300     ASSERT_FALSE(ret);
1301     inputEvent->extraDataLength_ = 10;
1302     ret = inputEvent->ReadFromParcel(in);
1303     ASSERT_FALSE(ret);
1304 }
1305 
1306 /**
1307  * @tc.name: PointerEventTest_ActionToShortStr_002
1308  * @tc.desc: Verify ActionToShortStr
1309  * @tc.type: FUNC
1310  * @tc.require:
1311  * @tc.author:
1312  */
1313 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_002, TestSize.Level1)
1314 {
1315     CALL_TEST_DEBUG;
1316     auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1317     int32_t action = InputEvent::ACTION_CANCEL;
1318     auto ret = inputEvent->ActionToShortStr(action);
1319     ASSERT_EQ(ret, "B:C:");
1320     action = InputEvent::ACTION_UNKNOWN;
1321     ret = inputEvent->ActionToShortStr(action);
1322     ASSERT_EQ(ret, "B:UK:");
1323     action = InputEvent::EVENT_FLAG_HIDE_POINTER;
1324     ret = inputEvent->ActionToShortStr(action);
1325     ASSERT_EQ(ret, "B:?:");
1326 }
1327 
1328 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
1329 /**
1330  * @tc.name: PointerEventTest_SetFingerprintDistanceX_001
1331  * @tc.desc: Set the fingerprint distance X.
1332  * @tc.type: FUNC
1333  * @tc.require:
1334  */
1335 HWTEST_F(PointerEventTest, PointerEventTest_SetFingerprintDistanceX_001, TestSize.Level1)
1336 {
1337     CALL_TEST_DEBUG;
1338     auto pointerEvent = PointerEvent::Create();
1339     ASSERT_NE(pointerEvent, nullptr);
1340     double x = 10.0;
1341     ASSERT_NO_FATAL_FAILURE(pointerEvent->SetFingerprintDistanceX(x));
1342     ASSERT_EQ(pointerEvent->GetFingerprintDistanceX(), x);
1343 }
1344 
1345 /**
1346  * @tc.name: PointerEventTest_SetFingerprintDistanceY_001
1347  * @tc.desc: Set the fingerprint distance Y.
1348  * @tc.type: FUNC
1349  * @tc.require:
1350  */
1351 HWTEST_F(PointerEventTest, PointerEventTest_SetFingerprintDistanceY_001, TestSize.Level1)
1352 {
1353     CALL_TEST_DEBUG;
1354     auto pointerEvent = PointerEvent::Create();
1355     ASSERT_NE(pointerEvent, nullptr);
1356     double y = 10.0;
1357     ASSERT_NO_FATAL_FAILURE(pointerEvent->SetFingerprintDistanceY(y));
1358     ASSERT_EQ(pointerEvent->GetFingerprintDistanceY(), y);
1359 }
1360 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
1361 
1362 /**
1363  * @tc.name: PointerEventTest_SetHandlerEventType
1364  * @tc.desc: Verify SetHandlerEventType
1365  * @tc.type: FUNC
1366  * @tc.require:
1367  * @tc.author:
1368  */
1369 HWTEST_F(PointerEventTest, PointerEventTest_SetHandlerEventType, TestSize.Level1)
1370 {
1371     CALL_TEST_DEBUG;
1372     auto pointerEvent = PointerEvent::Create();
1373     ASSERT_NE(pointerEvent, nullptr);
1374     pointerEvent->SetHandlerEventType(0);
1375     ASSERT_EQ(pointerEvent->GetHandlerEventType(), 0);
1376 }
1377 
1378 /**
1379  * @tc.name: PointerEventTest_GetAxisValue_001
1380  * @tc.desc: Test the funcation GetAxisValue
1381  * @tc.type: FUNC
1382  * @tc.require:
1383  */
1384 HWTEST_F(PointerEventTest, PointerEventTest_GetAxisValue_001, TestSize.Level1)
1385 {
1386     CALL_TEST_DEBUG;
1387     std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
1388     ASSERT_NE(pointerEvent, nullptr);
1389     PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1390     ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1391     axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1392     ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1393     axis = PointerEvent::AXIS_TYPE_PINCH;
1394     ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1395 }
1396 
1397 /**
1398  * @tc.name: PointerEventTest_SetAxisValue_001
1399  * @tc.desc: Test the funcation SetAxisValue
1400  * @tc.type: FUNC
1401  * @tc.require:
1402  */
1403 HWTEST_F(PointerEventTest, PointerEventTest_SetAxisValue_001, TestSize.Level1)
1404 {
1405     CALL_TEST_DEBUG;
1406     std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
1407     ASSERT_NE(pointerEvent, nullptr);
1408     double axisValue = 1.0;
1409     PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1410     ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1411     axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1412     ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1413     axis = PointerEvent::AXIS_TYPE_PINCH;
1414     ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1415 }
1416 
1417 /**
1418  * @tc.name: PointerEventTest_HasAxis_001
1419  * @tc.desc: Test the funcation HasAxis
1420  * @tc.type: FUNC
1421  * @tc.require:
1422  */
1423 HWTEST_F(PointerEventTest, PointerEventTest_HasAxis_001, TestSize.Level1)
1424 {
1425     CALL_TEST_DEBUG;
1426     std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
1427     ASSERT_NE(pointerEvent, nullptr);
1428     uint32_t axes = 1;
1429     PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1430     bool ret = pointerEvent->HasAxis(axes, axis);
1431     ASSERT_FALSE(ret);
1432     axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1433     ret = pointerEvent->HasAxis(axes, axis);
1434     ASSERT_TRUE(ret);
1435     axis = PointerEvent::AXIS_TYPE_PINCH;
1436     ret = pointerEvent->HasAxis(axes, axis);
1437     ASSERT_FALSE(ret);
1438 }
1439 
1440 /**
1441  * @tc.name: PointerEventTest_SetPressure_001
1442  * @tc.desc: Test the funcation SetPressure
1443  * @tc.type: FUNC
1444  * @tc.require:
1445  */
1446 HWTEST_F(PointerEventTest, PointerEventTest_SetPressure_001, TestSize.Level1)
1447 {
1448     CALL_TEST_DEBUG;
1449     double pressure = -1.0;
1450     PointerEvent::PointerItem item;
1451     ASSERT_NO_FATAL_FAILURE(item.SetPressure(pressure));
1452     pressure = 1.0;
1453     ASSERT_NO_FATAL_FAILURE(item.SetPressure(pressure));
1454 }
1455 
1456 /**
1457  * @tc.name: PointerEventTest_ActionToShortStr_003
1458  * @tc.desc: Test the funcation ActionToShortStr
1459  * @tc.type: FUNC
1460  * @tc.require:
1461  */
1462 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_003, TestSize.Level1)
1463 {
1464     CALL_TEST_DEBUG;
1465     std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
1466     ASSERT_NE(pointerEvent, nullptr);
1467     int32_t action = PointerEvent::POINTER_ACTION_PULL_UP;
1468     auto ret = pointerEvent->ActionToShortStr(action);
1469     ASSERT_EQ(ret, "P:PU:");
1470     action = PointerEvent::POINTER_ACTION_PULL_IN_WINDOW;
1471     ret = pointerEvent->ActionToShortStr(action);
1472     ASSERT_EQ(ret, "P:PI:");
1473     action = PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW;
1474     ret = pointerEvent->ActionToShortStr(action);
1475     ASSERT_EQ(ret, "P:PO:");
1476     action = PointerEvent::POINTER_ACTION_SWIPE_BEGIN;
1477     ret = pointerEvent->ActionToShortStr(action);
1478     ASSERT_EQ(ret, "P:SB:");
1479     action = PointerEvent::POINTER_ACTION_SWIPE_UPDATE;
1480     ret = pointerEvent->ActionToShortStr(action);
1481     ASSERT_EQ(ret, "P:SU:");
1482     action = PointerEvent::POINTER_ACTION_SWIPE_END;
1483     ret = pointerEvent->ActionToShortStr(action);
1484     ASSERT_EQ(ret, "P:SE:");
1485     action = PointerEvent::POINTER_ACTION_ROTATE_BEGIN;
1486     ret = pointerEvent->ActionToShortStr(action);
1487     ASSERT_EQ(ret, "P:RB:");
1488     action = PointerEvent::POINTER_ACTION_ROTATE_UPDATE;
1489     ret = pointerEvent->ActionToShortStr(action);
1490     ASSERT_EQ(ret, "P:RU:");
1491     action = PointerEvent::POINTER_ACTION_ROTATE_END;
1492     ret = pointerEvent->ActionToShortStr(action);
1493     ASSERT_EQ(ret, "P:RE:");
1494     action = PointerEvent::POINTER_ACTION_TRIPTAP;
1495     ret = pointerEvent->ActionToShortStr(action);
1496     ASSERT_EQ(ret, "P:TT:");
1497 }
1498 
1499 /**
1500  * @tc.name: PointerEventTest_ActionToShortStr_004
1501  * @tc.desc: Test the funcation ActionToShortStr
1502  * @tc.type: FUNC
1503  * @tc.require:
1504  */
1505 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_004, TestSize.Level1)
1506 {
1507     CALL_TEST_DEBUG;
1508     std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
1509     ASSERT_NE(pointerEvent, nullptr);
1510     int32_t action = PointerEvent::POINTER_ACTION_QUADTAP;
1511     auto ret = pointerEvent->ActionToShortStr(action);
1512     ASSERT_EQ(ret, "P:Q:");
1513     action = PointerEvent::POINTER_ACTION_HOVER_MOVE;
1514     ret = pointerEvent->ActionToShortStr(action);
1515     ASSERT_EQ(ret, "P:HM:");
1516     action = PointerEvent::POINTER_ACTION_HOVER_ENTER;
1517     ret = pointerEvent->ActionToShortStr(action);
1518     ASSERT_EQ(ret, "P:HE:");
1519     action = PointerEvent::POINTER_ACTION_FINGERPRINT_DOWN;
1520     ret = pointerEvent->ActionToShortStr(action);
1521     ASSERT_EQ(ret, "P:FD:");
1522     action = PointerEvent::POINTER_ACTION_FINGERPRINT_UP;
1523     ret = pointerEvent->ActionToShortStr(action);
1524     ASSERT_EQ(ret, "P:FU:");
1525     action = PointerEvent::POINTER_ACTION_FINGERPRINT_SLIDE;
1526     ret = pointerEvent->ActionToShortStr(action);
1527     ASSERT_EQ(ret, "P:FS:");
1528     action = PointerEvent::POINTER_ACTION_FINGERPRINT_RETOUCH;
1529     ret = pointerEvent->ActionToShortStr(action);
1530     ASSERT_EQ(ret, "P:FR:");
1531     action = PointerEvent::POINTER_ACTION_FINGERPRINT_CLICK;
1532     ret = pointerEvent->ActionToShortStr(action);
1533     ASSERT_EQ(ret, "P:FC:");
1534     action = PointerEvent::POINTER_ACTION_UNKNOWN;
1535     ret = pointerEvent->ActionToShortStr(action);
1536     ASSERT_EQ(ret, "P:UK:");
1537     action = 100;
1538     ret = pointerEvent->ActionToShortStr(action);
1539     ASSERT_EQ(ret, "P:?:");
1540 }
1541 
1542 /**
1543  * @tc.name: PointerEventTest_SetTiltX_001
1544  * @tc.desc: Test the funcation SetTiltX and GetTiltX
1545  * @tc.type: FUNC
1546  * @tc.require:
1547  */
1548 HWTEST_F(PointerEventTest, PointerEventTest_SetTiltX_001, TestSize.Level1)
1549 {
1550     CALL_TEST_DEBUG;
1551     double x = 10.0;
1552     PointerEvent::PointerItem item;
1553     ASSERT_NO_FATAL_FAILURE(item.SetTiltX(x));
1554     ASSERT_EQ(item.GetTiltX(), x);
1555 }
1556 
1557 /**
1558  * @tc.name: PointerEventTest_SetTiltY_001
1559  * @tc.desc: Test the funcation SetTiltY and GetTiltY
1560  * @tc.type: FUNC
1561  * @tc.require:
1562  */
1563 HWTEST_F(PointerEventTest, PointerEventTest_SetTiltY_001, TestSize.Level1)
1564 {
1565     CALL_TEST_DEBUG;
1566     double y = 10.0;
1567     PointerEvent::PointerItem item;
1568     ASSERT_NO_FATAL_FAILURE(item.SetTiltY(y));
1569     ASSERT_EQ(item.GetTiltY(), y);
1570 }
1571 
1572 /**
1573  * @tc.name: PointerEventTest_SetRawDisplayX_001
1574  * @tc.desc: Sets the raw X coordinate.
1575  * @tc.type: FUNC
1576  * @tc.require:
1577  */
1578 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDisplayX_001, TestSize.Level1)
1579 {
1580     CALL_TEST_DEBUG;
1581     int32_t rawDisplayX = 60;
1582     PointerEvent::PointerItem item;
1583     item.SetPointerId(8);
1584     item.SetDownTime(1);
1585     ASSERT_NO_FATAL_FAILURE(item.SetRawDisplayX(rawDisplayX));
1586     ASSERT_EQ(item.GetRawDisplayX(), rawDisplayX);
1587 }
1588 
1589 /**
1590  * @tc.name: PointerEventTest_SetRawDisplayY_001
1591  * @tc.desc: Sets the raw Y coordinate.
1592  * @tc.type: FUNC
1593  * @tc.require:
1594  */
1595 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDisplayY_001, TestSize.Level1)
1596 {
1597     CALL_TEST_DEBUG;
1598     int32_t rawDisplayY = 60;
1599     PointerEvent::PointerItem item;
1600     item.SetPointerId(8);
1601     item.SetDownTime(1);
1602     ASSERT_NO_FATAL_FAILURE(item.SetRawDisplayY(rawDisplayY));
1603     ASSERT_EQ(item.GetRawDisplayY(), rawDisplayY);
1604 }
1605 
1606 /**
1607  * @tc.name: PointerEventTest_EventTypeToString_001
1608  * @tc.desc: Test the funcation EventTypeToString
1609  * @tc.type: FUNC
1610  * @tc.require:
1611  */
1612 HWTEST_F(PointerEventTest, PointerEventTest_EventTypeToString_001, TestSize.Level1)
1613 {
1614     CALL_TEST_DEBUG;
1615     auto inputEvent = InputEvent::Create();
1616     ASSERT_NE(inputEvent, nullptr);
1617     int32_t eventType = InputEvent::EVENT_TYPE_BASE;
1618     std::string ret = inputEvent->EventTypeToString(eventType);
1619     ASSERT_EQ(ret, "base");
1620     eventType = InputEvent::EVENT_TYPE_KEY;
1621     ret = inputEvent->EventTypeToString(eventType);
1622     ASSERT_EQ(ret, "key");
1623     eventType = InputEvent::EVENT_TYPE_POINTER;
1624     ret = inputEvent->EventTypeToString(eventType);
1625     ASSERT_EQ(ret, "pointer");
1626     eventType = InputEvent::EVENT_TYPE_AXIS;
1627     ret = inputEvent->EventTypeToString(eventType);
1628     ASSERT_EQ(ret, "axis");
1629     eventType = InputEvent::EVENT_TYPE_FINGERPRINT;
1630     ret = inputEvent->EventTypeToString(eventType);
1631     ASSERT_EQ(ret, "fingerprint");
1632     eventType = InputEvent::EVENT_FLAG_NO_INTERCEPT;
1633     ret = inputEvent->EventTypeToString(eventType);
1634     ASSERT_EQ(ret, "unknown");
1635 }
1636 
1637 /**
1638  * @tc.name: PointerEventTest_MarkProcessed_002
1639  * @tc.desc: Test the funcation MarkProcessed
1640  * @tc.type: FUNC
1641  * @tc.require:
1642  * @tc.author:
1643  */
1644 HWTEST_F(PointerEventTest, PointerEventTest_MarkProcessed_002, TestSize.Level1)
1645 {
1646     CALL_TEST_DEBUG;
1647     auto inputEvent = InputEvent::Create();
1648     ASSERT_NE(inputEvent, nullptr);
__anon501b1d230202(int a, int b) 1649     auto callback = [](int a, int b) {};
1650     inputEvent->processedCallback_ = callback;
1651     inputEvent->processedCallback_(10, 20);
1652     inputEvent->markEnabled_ = false;
1653     ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1654     inputEvent->markEnabled_ = true;
1655     ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1656 }
1657 
1658 /**
1659  * @tc.name: PointerEventTest_SetExtraData_005
1660  * @tc.desc: Set extra data
1661  * @tc.type: FUNC
1662  * @tc.require:
1663  */
1664 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_005, TestSize.Level1)
1665 {
1666     CALL_TEST_DEBUG;
1667     auto inputEvent = InputEvent::Create();
1668     ASSERT_NE(inputEvent, nullptr);
1669     uint32_t length = 5;
1670     uint8_t data[5] = {1, 2, 3, 4, 5};
__anon501b1d230302(const uint8_t*) 1671     std::shared_ptr<const uint8_t[]> sharedData(data, [](const uint8_t*) {});
1672     ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1673     length = -5;
1674     ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1675     length = 2000;
1676     ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1677 }
1678 
1679 /**
1680  * @tc.name: PointerEventTest_GetExtraData_004
1681  * @tc.desc: Verify GetExtraData
1682  * @tc.type: FUNC
1683  * @tc.require:
1684  * @tc.author:
1685  */
1686 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_004, TestSize.Level1)
1687 {
1688     CALL_TEST_DEBUG;
1689     auto inputEvent = InputEvent::Create();
1690     ASSERT_NE(inputEvent, nullptr);
1691     uint32_t length = 5;
1692     inputEvent->extraDataLength_ = 5;
1693     std::shared_ptr<const uint8_t[]> data;
1694     ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1695     inputEvent->extraDataLength_ = 0;
1696     ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1697     uint8_t datas[5] = {1, 2, 3, 4, 5};
__anon501b1d230402(const uint8_t*) 1698     std::shared_ptr<const uint8_t[]> sharedData(datas, [](const uint8_t*) {});
1699     ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1700     inputEvent->extraDataLength_ = 10;
1701     ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1702     inputEvent->extraDataLength_ = 0;
1703     ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1704 }
1705 
1706 /**
1707  * @tc.name: PointerEventTest_WriteToParcel_003
1708  * @tc.desc: Verify WriteToParcel
1709  * @tc.type: FUNC
1710  * @tc.require:
1711  * @tc.author:
1712  */
1713 HWTEST_F(PointerEventTest, PointerEventTest_WriteToParcel_003, TestSize.Level1)
1714 {
1715     CALL_TEST_DEBUG;
1716     auto inputEvent = InputEvent::Create();
1717     ASSERT_NE(inputEvent, nullptr);
1718     Parcel out;
1719     uint32_t length = 5;
1720     inputEvent->extraDataLength_ = 0;
1721     bool ret = inputEvent->WriteToParcel(out);
1722     ASSERT_TRUE(ret);
1723     inputEvent->extraDataLength_ = 5;
1724     ret = inputEvent->WriteToParcel(out);
1725     ASSERT_TRUE(ret);
1726     uint8_t datas[5] = {1, 2, 3, 4, 5};
__anon501b1d230502(const uint8_t*) 1727     std::shared_ptr<const uint8_t[]> sharedData(datas, [](const uint8_t*) {});
1728     ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1729     inputEvent->extraDataLength_ = 0;
1730     ret = inputEvent->WriteToParcel(out);
1731     ASSERT_TRUE(ret);
1732     inputEvent->extraDataLength_ = 5;
1733     ret = inputEvent->WriteToParcel(out);
1734     ASSERT_TRUE(ret);
1735 }
1736 } // namespace MMI
1737 } // namespace OHOS
1738