1 /*
2 * Copyright (c) 2021-2025 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:
SetUpTestCase(void)34 static void SetUpTestCase(void) {}
TearDownTestCase(void)35 static void TearDownTestCase(void) {}
36 static std::shared_ptr<PointerEvent> CreatePointEvent();
37 };
38
39 #ifdef OHOS_BUILD_ENABLE_POINTER
CreatePointEvent()40 std::shared_ptr<PointerEvent> PointerEventTest::CreatePointEvent()
41 {
42 auto pointerEvent = PointerEvent::Create();
43 CHKPP(pointerEvent);
44 int64_t downTime = GetMillisTime();
45 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
46 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
47 pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
48 pointerEvent->SetPointerId(1);
49 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
50 PointerEvent::PointerItem item;
51 item.SetPointerId(1);
52 item.SetDownTime(downTime);
53 item.SetPressed(true);
54
55 item.SetDisplayX(623);
56 item.SetDisplayY(823);
57 item.SetGlobalX(0);
58 item.SetGlobalY(0);
59 item.SetWindowX(600);
60 item.SetWindowY(800);
61
62 item.SetWidth(0);
63 item.SetHeight(0);
64 item.SetPressure(0);
65 item.SetDeviceId(0);
66 pointerEvent->AddPointerItem(item);
67 return pointerEvent;
68 }
69 #endif // OHOS_BUILD_ENABLE_POINTER
70
MyCallback(int32_t paramA,int64_t paramB)71 void MyCallback(int32_t paramA, int64_t paramB)
72 {
73 return;
74 }
75
76 /**
77 * @tc.name: PointerEventTest_CheckMousePointEvent_001
78 * @tc.desc: Verify mouse point event
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_001, TestSize.Level2)
83 {
84 CALL_TEST_DEBUG;
85 auto pointerEvent = PointerEvent::Create();
86 ASSERT_NE(pointerEvent, nullptr);
87 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
88 ASSERT_TRUE(!pointerEvent->IsValid());
89
90 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
91 pointerEvent->SetPointerId(-1);
92 ASSERT_TRUE(!pointerEvent->IsValid());
93
94 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
95 pointerEvent->SetPointerId(0);
96 PointerEvent::PointerItem item1;
97 item1.SetPointerId(0);
98 pointerEvent->AddPointerItem(item1);
99 PointerEvent::PointerItem item2;
100 item2.SetPointerId(0);
101 pointerEvent->AddPointerItem(item2);
102 ASSERT_TRUE(!pointerEvent->IsValid());
103 PointerEvent::PointerItem item3;
104 item3.SetPointerId(0);
105 pointerEvent->AddPointerItem(item3);
106 PointerEvent::PointerItem item4;
107 item4.SetPointerId(0);
108 pointerEvent->AddPointerItem(item4);
109 PointerEvent::PointerItem item5;
110 item5.SetPointerId(0);
111 pointerEvent->AddPointerItem(item5);
112 PointerEvent::PointerItem item6;
113 item6.SetPointerId(0);
114 pointerEvent->AddPointerItem(item6);
115
116 auto pointerEvent1 = PointerEvent::Create();
117 ASSERT_NE(pointerEvent1, nullptr);
118 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
119 pointerEvent1->SetPointerId(0);
120 pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
121 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
122 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_RIGHT);
123 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_MIDDLE);
124 item1.SetPointerId(0);
125 pointerEvent1->AddPointerItem(item1);
126 ASSERT_TRUE(!pointerEvent1->IsValid());
127 }
128
129 /**
130 * @tc.name: PointerEventTest_CheckMousePointEvent_002
131 * @tc.desc: Verify mouse point event
132 * @tc.type: FUNC
133 * @tc.require:
134 */
135 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_002, TestSize.Level2)
136 {
137 CALL_TEST_DEBUG;
138 auto pointerEvent1 = PointerEvent::Create();
139 ASSERT_NE(pointerEvent1, nullptr);
140 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
141 pointerEvent1->SetPointerId(0);
142 pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
143 PointerEvent::PointerItem item;
144 item.SetPointerId(0);
145 pointerEvent1->AddPointerItem(item);
146 ASSERT_TRUE(!pointerEvent1->IsValid());
147
148 auto pointerEvent2 = PointerEvent::Create();
149 ASSERT_NE(pointerEvent2, nullptr);
150 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
151 pointerEvent2->SetPointerId(0);
152 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
153 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
154 item.SetPointerId(0);
155 pointerEvent2->AddPointerItem(item);
156 ASSERT_TRUE(!pointerEvent2->IsValid());
157
158 auto pointerEvent3 = PointerEvent::Create();
159 ASSERT_NE(pointerEvent3, nullptr);
160 pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
161 pointerEvent3->SetPointerId(0);
162 pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
163 pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
164 pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
165 item.SetPointerId(0);
166 pointerEvent3->AddPointerItem(item);
167 ASSERT_TRUE(!pointerEvent3->IsValid());
168 }
169
170 /**
171 * @tc.name: PointerEventTest_CheckMousePointEvent_003
172 * @tc.desc: Verify mouse point event
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_003, TestSize.Level2)
177 {
178 CALL_TEST_DEBUG;
179 auto pointerEvent1 = PointerEvent::Create();
180 ASSERT_NE(pointerEvent1, nullptr);
181 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
182 pointerEvent1->SetPointerId(0);
183 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
184 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
185 pointerEvent1->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
186 PointerEvent::PointerItem item;
187 item.SetPointerId(0);
188 pointerEvent1->AddPointerItem(item);
189 ASSERT_TRUE(!pointerEvent1->IsValid());
190
191 auto pointerEvent2 = PointerEvent::Create();
192 ASSERT_NE(pointerEvent2, nullptr);
193 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
194 pointerEvent2->SetPointerId(0);
195 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
196 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
197 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
198 item.SetPointerId(-1);
199 pointerEvent2->AddPointerItem(item);
200 ASSERT_TRUE(!pointerEvent2->IsValid());
201 }
202
203 /**
204 * @tc.name: PointerEventTest_CheckMousePointEvent_004
205 * @tc.desc: Verify mouse point event
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_004, TestSize.Level2)
210 {
211 CALL_TEST_DEBUG;
212 auto pointerEvent1 = PointerEvent::Create();
213 ASSERT_NE(pointerEvent1, nullptr);
214 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
215 pointerEvent1->SetPointerId(0);
216 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
217 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
218 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
219 PointerEvent::PointerItem item;
220 item.SetPointerId(2);
221 pointerEvent1->AddPointerItem(item);
222 ASSERT_TRUE(!pointerEvent1->IsValid());
223
224 auto pointerEvent2 = PointerEvent::Create();
225 ASSERT_NE(pointerEvent2, nullptr);
226 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
227 pointerEvent2->SetPointerId(0);
228 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
229 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
230 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
231 item.SetPointerId(0);
232 item.SetDownTime(10010);
233 pointerEvent2->AddPointerItem(item);
234 ASSERT_TRUE(!pointerEvent2->IsValid());
235
236 auto pointerEvent3 = PointerEvent::Create();
237 ASSERT_NE(pointerEvent3, nullptr);
238 pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
239 pointerEvent3->SetPointerId(0);
240 pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
241 pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
242 pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
243 item.SetPointerId(0);
244 item.SetDownTime(0);
245 item.SetPressed(true);
246 pointerEvent3->AddPointerItem(item);
247 ASSERT_TRUE(!pointerEvent3->IsValid());
248 }
249
250 /**
251 * @tc.name: PointerEventTest_CheckMousePointEvent_005
252 * @tc.desc: Verify mouse point event
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_005, TestSize.Level2)
257 {
258 CALL_TEST_DEBUG;
259 auto pointerEvent = PointerEvent::Create();
260 ASSERT_NE(pointerEvent, nullptr);
261 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
262 pointerEvent->SetPointerId(0);
263 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
264 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
265 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
266 PointerEvent::PointerItem item;
267 item.SetPointerId(0);
268 item.SetDownTime(0);
269 item.SetPressed(false);
270 pointerEvent->AddPointerItem(item);
271 ASSERT_TRUE(pointerEvent->IsValid());
272 }
273
274 /**
275 * @tc.name: PointerEventTest_CheckMousePointEvent_006
276 * @tc.desc: Verify mouse point event
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_006, TestSize.Level2)
281 {
282 CALL_TEST_DEBUG;
283 auto inputEvent = InputEvent::Create();
284 ASSERT_NE(inputEvent, nullptr);
285 inputEvent->SetDeviceId(1);
286 inputEvent->SetTargetWindowId(1);
287 inputEvent->SetAgentWindowId(1);
288 auto event = PointerEvent::from(inputEvent);
289 ASSERT_EQ(event, nullptr);
290
291 auto pointerEvent = PointerEvent::Create();
292 ASSERT_NE(pointerEvent, nullptr);
293 pointerEvent->Reset();
294 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
295 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
296 pointerEvent->SetPointerId(0);
297 pointerEvent->SetDeviceId(inputEvent->GetDeviceId());
298 pointerEvent->SetTargetWindowId(inputEvent->GetTargetWindowId());
299 pointerEvent->SetAgentWindowId(inputEvent->GetAgentWindowId());
300 PointerEvent::PointerItem item1;
301 item1.SetPointerId(0);
302 item1.SetDownTime(0);
303 item1.SetPressed(true);
304 item1.SetWindowX(10);
305 item1.SetWindowY(10);
306 item1.SetDeviceId(inputEvent->GetDeviceId());
307 item1.SetRawDx(60);
308 item1.SetRawDy(60);
309 pointerEvent->AddPointerItem(item1);
310 PointerEvent::PointerItem item2;
311 item2.SetPointerId(1);
312 item2.SetDownTime(0);
313 item2.SetPressed(false);
314 item2.SetWindowX(item1.GetWindowX());
315 item2.SetWindowY(item1.GetWindowY());
316 item2.SetDeviceId(inputEvent->GetDeviceId());
317 item2.SetRawDx(100);
318 item2.SetRawDy(100);
319 pointerEvent->AddPointerItem(item2);
320 ASSERT_TRUE(pointerEvent != nullptr);
321 }
322
323 /**
324 * @tc.name: PointerEventTest_CheckTouchPointEvent_001
325 * @tc.desc: Verify touch screen event
326 * @tc.type: FUNC
327 * @tc.require:
328 */
329 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_001, TestSize.Level2)
330 {
331 CALL_TEST_DEBUG;
332 auto pointerEvent = PointerEvent::Create();
333 ASSERT_NE(pointerEvent, nullptr);
334 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
335 pointerEvent->SetPointerId(-1);
336 ASSERT_TRUE(!pointerEvent->IsValid());
337
338 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
339 pointerEvent->SetPointerId(0);
340 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
341 ASSERT_TRUE(!pointerEvent->IsValid());
342
343 auto pointerEvent1 = PointerEvent::Create();
344 ASSERT_NE(pointerEvent1, nullptr);
345 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
346 pointerEvent1->SetPointerId(0);
347 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
348 ASSERT_TRUE(!pointerEvent1->IsValid());
349
350 auto pointerEvent2 = PointerEvent::Create();
351 ASSERT_NE(pointerEvent2, nullptr);
352 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
353 pointerEvent2->SetPointerId(0);
354 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
355 pointerEvent2->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
356 ASSERT_TRUE(!pointerEvent2->IsValid());
357 }
358
359 /**
360 * @tc.name: PointerEventTest_CheckTouchPointEvent_002
361 * @tc.desc: Verify touch screen event
362 * @tc.type: FUNC
363 * @tc.require:
364 */
365 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_002, TestSize.Level2)
366 {
367 CALL_TEST_DEBUG;
368 auto pointerEvent1 = PointerEvent::Create();
369 ASSERT_NE(pointerEvent1, nullptr);
370 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
371 pointerEvent1->SetPointerId(0);
372 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
373 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
374 PointerEvent::PointerItem item;
375 item.SetPointerId(-1);
376 pointerEvent1->AddPointerItem(item);
377 ASSERT_TRUE(!pointerEvent1->IsValid());
378
379 auto pointerEvent2 = PointerEvent::Create();
380 ASSERT_NE(pointerEvent2, nullptr);
381 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
382 pointerEvent2->SetPointerId(0);
383 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
384 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
385 item.SetPointerId(0);
386 item.SetDownTime(0);
387 item.SetPressed(false);
388 pointerEvent2->AddPointerItem(item);
389 ASSERT_TRUE(!pointerEvent2->IsValid());
390 }
391
392 /**
393 * @tc.name: PointerEventTest_CheckTouchPointEvent_003
394 * @tc.desc: Verify touch screen event
395 * @tc.type: FUNC
396 * @tc.require:
397 */
398 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_003, TestSize.Level2)
399 {
400 CALL_TEST_DEBUG;
401 auto pointerEvent1 = PointerEvent::Create();
402 ASSERT_NE(pointerEvent1, nullptr);
403 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
404 pointerEvent1->SetPointerId(0);
405 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
406 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
407 PointerEvent::PointerItem item;
408 item.SetPointerId(0);
409 item.SetDownTime(100);
410 item.SetPressed(true);
411 pointerEvent1->AddPointerItem(item);
412 ASSERT_TRUE(!pointerEvent1->IsValid());
413
414 auto pointerEvent2 = PointerEvent::Create();
415 ASSERT_NE(pointerEvent2, nullptr);
416 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
417 pointerEvent2->SetPointerId(0);
418 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
419 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
420 PointerEvent::PointerItem item1;
421 item1.SetPointerId(0);
422 item1.SetDownTime(100);
423 item1.SetPressed(false);
424 pointerEvent2->AddPointerItem(item1);
425 PointerEvent::PointerItem item2;
426 item2.SetPointerId(0);
427 item2.SetDownTime(100);
428 item2.SetPressed(false);
429 pointerEvent2->AddPointerItem(item2);
430 ASSERT_FALSE(!pointerEvent2->IsValid());
431 }
432
433 /**
434 * @tc.name: PointerEventTest_CheckTouchPointEvent_004
435 * @tc.desc: Verify touch screen event
436 * @tc.type: FUNC
437 * @tc.require:
438 */
439 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_004, TestSize.Level2)
440 {
441 CALL_TEST_DEBUG;
442 auto pointerEvent = PointerEvent::Create();
443 ASSERT_NE(pointerEvent, nullptr);
444 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
445 pointerEvent->SetPointerId(0);
446 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
447 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
448 PointerEvent::PointerItem item1;
449 item1.SetPointerId(1);
450 item1.SetDownTime(100);
451 item1.SetPressed(false);
452 pointerEvent->AddPointerItem(item1);
453 PointerEvent::PointerItem item2;
454 item2.SetPointerId(2);
455 item2.SetDownTime(100);
456 item2.SetPressed(false);
457 pointerEvent->AddPointerItem(item2);
458 ASSERT_TRUE(!pointerEvent->IsValid());
459 }
460
461 /**
462 * @tc.name: PointerEventTest_CheckTouchPointEvent_005
463 * @tc.desc: Verify touch screen event
464 * @tc.type: FUNC
465 * @tc.require:
466 */
467 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_005, TestSize.Level2)
468 {
469 CALL_TEST_DEBUG;
470 auto pointerEvent = PointerEvent::Create();
471 ASSERT_NE(pointerEvent, nullptr);
472 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
473 pointerEvent->SetPointerId(0);
474 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
475 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
476 PointerEvent::PointerItem item1;
477 item1.SetPointerId(0);
478 item1.SetDownTime(100);
479 item1.SetPressed(false);
480 pointerEvent->AddPointerItem(item1);
481 PointerEvent::PointerItem item2;
482 item2.SetPointerId(1);
483 item2.SetDownTime(100);
484 item2.SetPressed(false);
485 pointerEvent->AddPointerItem(item2);
486 ASSERT_TRUE(pointerEvent->IsValid());
487 }
488
489 /**
490 * @tc.name: PointerEventTest_CheckTouchPointEvent_006
491 * @tc.desc: Verify touch screen event
492 * @tc.type: FUNC
493 * @tc.require: I5QSN3
494 */
495 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_006, TestSize.Level2)
496 {
497 CALL_TEST_DEBUG;
498 auto pointerEvent = PointerEvent::Create();
499 ASSERT_NE(pointerEvent, nullptr);
500 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
501 pointerEvent->SetPointerId(0);
502 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
503 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
504 PointerEvent::PointerItem item;
505 item.SetPointerId(0);
506 item.SetDownTime(100);
507 item.SetToolDisplayX(90);
508 item.SetToolDisplayY(90);
509 item.SetToolWindowX(50);
510 item.SetToolWindowY(50);
511 item.SetToolWidth(30);
512 item.SetToolHeight(30);
513 item.SetLongAxis(100);
514 item.SetShortAxis(20);
515 item.SetToolType(2);
516 item.SetTargetWindowId(0);
517 pointerEvent->AddPointerItem(item);
518 ASSERT_TRUE(pointerEvent->IsValid());
519 DumpWindowData(pointerEvent);
520 pointerEvent->RemovePointerItem(0);
521 pointerEvent->IsButtonPressed(0);
522 pointerEvent->ClearButtonPressed();
523 pointerEvent->ClearAxisValue();
524 pointerEvent->DeleteReleaseButton(PointerEvent::BUTTON_NONE);
525 ASSERT_FALSE(pointerEvent->IsValid());
526 }
527
528 /**
529 * @tc.name: PointerEventTest_CheckTouchInputEvent_001
530 * @tc.desc: Verify touch screen event
531 * @tc.type: FUNC
532 * @tc.require: I5QSN3
533 */
534 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchInputEvent_001, TestSize.Level2)
535 {
536 CALL_TEST_DEBUG;
537 auto inputEvent = InputEvent::Create();
538 ASSERT_NE(inputEvent, nullptr);
539 inputEvent->SetTargetDisplayId(0);
540 inputEvent->SetDeviceId(0);
541 inputEvent->EventTypeToString(InputEvent::EVENT_TYPE_POINTER);
542 inputEvent->HasFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
543 inputEvent->ClearFlag();
544 }
545
546 /**
547 * @tc.name: PointerEventTest_SetEnhanceData_001
548 * @tc.desc: Set the enhance data.
549 * @tc.type: FUNC
550 * @tc.require:
551 */
552 HWTEST_F(PointerEventTest, PointerEventTest_SetEnhanceData_001, TestSize.Level2)
553 {
554 CALL_TEST_DEBUG;
555 auto pointerEvent = PointerEvent::Create();
556 ASSERT_NE(pointerEvent, nullptr);
557 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
558 pointerEvent->SetPointerId(0);
559 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
560 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
561 PointerEvent::PointerItem item;
562 item.SetPointerId(-1);
563 pointerEvent->AddPointerItem(item);
564 uint32_t enHanceDataLen = 3;
565 uint8_t enhanceDataBuf[enHanceDataLen];
566 std::vector<uint8_t> enhanceData;
567 for (uint32_t i = 0; i < enHanceDataLen; i++) {
568 enhanceData.push_back(enhanceDataBuf[i]);
569 }
570 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
571 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetEnhanceData(enhanceData));
572 ASSERT_EQ(pointerEvent->GetEnhanceData(), enhanceData);
573 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
574 }
575
576 /**
577 * @tc.name: PointerEventTest_SetToolDisplayX_001
578 * @tc.desc: Set Tool Display Coordinates.
579 * @tc.type: FUNC
580 * @tc.require:
581 */
582 HWTEST_F(PointerEventTest, PointerEventTest_SetToolDisplayX_001, TestSize.Level2)
583 {
584 CALL_TEST_DEBUG;
585 auto pointerEvent = PointerEvent::Create();
586 ASSERT_NE(pointerEvent, nullptr);
587 int32_t displayX = 90;
588 PointerEvent::PointerItem item;
589 item.SetPointerId(1);
590 item.SetDownTime(0);
591 ASSERT_NO_FATAL_FAILURE(item.SetToolDisplayX(displayX));
592 ASSERT_EQ(item.GetToolDisplayX(), displayX);
593 pointerEvent->AddPointerItem(item);
594 }
595
596 /**
597 * @tc.name: PointerEventTest_SetToolDisplayY_001
598 * @tc.desc: Set Tool Display Coordinates.
599 * @tc.type: FUNC
600 * @tc.require:
601 */
602 HWTEST_F(PointerEventTest, PointerEventTest_SetToolDisplayY_001, TestSize.Level2)
603 {
604 CALL_TEST_DEBUG;
605 auto pointerEvent = PointerEvent::Create();
606 ASSERT_NE(pointerEvent, nullptr);
607 int32_t displayY = 70;
608 PointerEvent::PointerItem item;
609 item.SetPointerId(2);
610 item.SetDownTime(1);
611 ASSERT_NO_FATAL_FAILURE(item.SetToolDisplayY(displayY));
612 ASSERT_EQ(item.GetToolDisplayY(), displayY);
613 pointerEvent->AddPointerItem(item);
614 }
615
616 /**
617 * @tc.name: PointerEventTest_SetToolWidth_001
618 * @tc.desc: Set Tool Display Width.
619 * @tc.type: FUNC
620 * @tc.require:
621 */
622 HWTEST_F(PointerEventTest, PointerEventTest_SetToolWidth_001, TestSize.Level2)
623 {
624 CALL_TEST_DEBUG;
625 int32_t toolWidth = 30;
626 PointerEvent::PointerItem item;
627 item.SetPointerId(3);
628 item.SetDownTime(0);
629 ASSERT_NO_FATAL_FAILURE(item.SetToolWidth(toolWidth));
630 ASSERT_EQ(item.GetToolWidth(), toolWidth);
631 }
632
633 /**
634 * @tc.name: PointerEventTest_SetToolHeight_001
635 * @tc.desc: Set Tool Display Height.
636 * @tc.type: FUNC
637 * @tc.require:
638 */
639 HWTEST_F(PointerEventTest, PointerEventTest_SetToolHeight_001, TestSize.Level2)
640 {
641 CALL_TEST_DEBUG;
642 int32_t toolHeight = 40;
643 PointerEvent::PointerItem item;
644 item.SetPointerId(4);
645 item.SetDownTime(1);
646 ASSERT_NO_FATAL_FAILURE(item.SetToolHeight(toolHeight));
647 ASSERT_EQ(item.GetToolHeight(), toolHeight);
648 }
649
650 /**
651 * @tc.name: PointerEventTest_SetLongAxis_001
652 * @tc.desc: Sets the long axis of the touch point area.
653 * @tc.type: FUNC
654 * @tc.require:
655 */
656 HWTEST_F(PointerEventTest, PointerEventTest_SetLongAxis_001, TestSize.Level2)
657 {
658 CALL_TEST_DEBUG;
659 int32_t longAxis = 50;
660 PointerEvent::PointerItem item;
661 item.SetPointerId(5);
662 item.SetDownTime(0);
663 ASSERT_NO_FATAL_FAILURE(item.SetLongAxis(longAxis));
664 ASSERT_EQ(item.GetLongAxis(), longAxis);
665 }
666
667 /**
668 * @tc.name: PointerEventTest_SetShortAxis_001
669 * @tc.desc: Sets the short axis of the touch point area.
670 * @tc.type: FUNC
671 * @tc.require:
672 */
673 HWTEST_F(PointerEventTest, PointerEventTest_SetShortAxis_001, TestSize.Level2)
674 {
675 CALL_TEST_DEBUG;
676 int32_t shortAxis = 45;
677 PointerEvent::PointerItem item;
678 item.SetPointerId(6);
679 item.SetDownTime(1);
680 ASSERT_NO_FATAL_FAILURE(item.SetShortAxis(shortAxis));
681 ASSERT_EQ(item.GetShortAxis(), shortAxis);
682 }
683
684 /**
685 * @tc.name: PointerEventTest_GetPointerCount_001
686 * @tc.desc: Get pointer count
687 * @tc.type: FUNC
688 * @tc.require:
689 */
690 HWTEST_F(PointerEventTest, PointerEventTest_GetPointerCount_001, TestSize.Level2)
691 {
692 CALL_TEST_DEBUG;
693 auto pointerEvent = PointerEvent::Create();
694 int32_t pointerCount = pointerEvent->GetPointerCount();
695 ASSERT_EQ(pointerCount, 0);
696 }
697
698 /**
699 * @tc.name: PointerEventTest_SetExtraData_001
700 * @tc.desc: Set extra data
701 * @tc.type: FUNC
702 * @tc.require:
703 */
704 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_001, TestSize.Level2)
705 {
706 CALL_TEST_DEBUG;
707 const uint32_t length = 5;
708 std::shared_ptr<const uint8_t[]> data;
709 auto inputEvent = InputEvent::Create();
710 ASSERT_NE(inputEvent, nullptr);
711 inputEvent->SetExtraData(data, length);
712 }
713
714 /**
715 * @tc.name: PointerEventTest_GetExtraData_001
716 * @tc.desc: Get extra data
717 * @tc.type: FUNC
718 * @tc.require:
719 */
720 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_001, TestSize.Level2)
721 {
722 CALL_TEST_DEBUG;
723 auto inputEvent = InputEvent::Create();
724 std::shared_ptr<const uint8_t[]> retrievedData;
725 uint32_t retrievedLength;
726 inputEvent->GetExtraData(retrievedData, retrievedLength);
727 }
728
729 /**
730 * @tc.name: PointerEventTest_SetRawDx_001
731 * @tc.desc: Sets the raw X coordinate.
732 * @tc.type: FUNC
733 * @tc.require:
734 */
735 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDx_001, TestSize.Level2)
736 {
737 CALL_TEST_DEBUG;
738 int32_t rawDx = 55;
739 PointerEvent::PointerItem item;
740 item.SetPointerId(7);
741 item.SetDownTime(0);
742 ASSERT_NO_FATAL_FAILURE(item.SetRawDx(rawDx));
743 ASSERT_EQ(item.GetRawDx(), rawDx);
744 }
745
746 /**
747 * @tc.name: PointerEventTest_SetRawDy_001
748 * @tc.desc: Sets the raw Y coordinate.
749 * @tc.type: FUNC
750 * @tc.require:
751 */
752 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDy_001, TestSize.Level2)
753 {
754 CALL_TEST_DEBUG;
755 int32_t rawDy = 60;
756 PointerEvent::PointerItem item;
757 item.SetPointerId(8);
758 item.SetDownTime(1);
759 ASSERT_NO_FATAL_FAILURE(item.SetRawDy(rawDy));
760 ASSERT_EQ(item.GetRawDy(), rawDy);
761 }
762
763 /**
764 * @tc.name: PointerEventTest_ClearFlag_001
765 * @tc.desc: Clears all flags of an input event.
766 * @tc.type: FUNC
767 * @tc.require:
768 */
769 HWTEST_F(PointerEventTest, PointerEventTest_ClearFlag_001, TestSize.Level2)
770 {
771 CALL_TEST_DEBUG;
772 auto inputEvent = InputEvent::Create();
773 ASSERT_NE(inputEvent, nullptr);
774 inputEvent->SetTargetDisplayId(0);
775 inputEvent->SetDeviceId(0);
776 inputEvent->EventTypeToString(InputEvent::EVENT_TYPE_POINTER);
777 inputEvent->AddFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
778 ASSERT_NO_FATAL_FAILURE(inputEvent->ClearFlag());
779 ASSERT_EQ(inputEvent->GetFlag(), InputEvent::EVENT_FLAG_NONE);
780 }
781
782 /**
783 * @tc.name: PointerEventTest_From_001
784 * @tc.desc: Convert InputEvent to nullptr.
785 * @tc.type: FUNC
786 * @tc.require:
787 */
788 HWTEST_F(PointerEventTest, PointerEventTest_From_001, TestSize.Level2)
789 {
790 CALL_TEST_DEBUG;
791 auto inputEvent = InputEvent::Create();
792 ASSERT_NE(inputEvent, nullptr);
793 inputEvent->SetDeviceId(2);
794 inputEvent->SetTargetWindowId(2);
795 inputEvent->SetAgentWindowId(2);
796 auto event = PointerEvent::from(inputEvent);
797 ASSERT_EQ(event, nullptr);
798 }
799
800 /**
801 * @tc.name: PointerEventTest_Reset_001
802 * @tc.desc: Reset pointer event.
803 * @tc.type: FUNC
804 * @tc.require:
805 */
806 HWTEST_F(PointerEventTest, PointerEventTest_Reset_001, TestSize.Level2)
807 {
808 CALL_TEST_DEBUG;
809 auto pointerEvent = PointerEvent::Create();
810 ASSERT_NE(pointerEvent, nullptr);
811 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
812 pointerEvent->SetPointerId(1);
813 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
814 ASSERT_NO_FATAL_FAILURE(pointerEvent->Reset());
815 ASSERT_EQ(pointerEvent->GetSourceType(), PointerEvent::SOURCE_TYPE_UNKNOWN);
816 ASSERT_EQ(pointerEvent->GetPointerId(), -1);
817 ASSERT_EQ(pointerEvent->GetPointerAction(), PointerEvent::POINTER_ACTION_UNKNOWN);
818 }
819
820 /**
821 * @tc.name: PointerEventTest_IsButtonPressed_001
822 * @tc.desc: Determine whether the button is pressed.
823 * @tc.type: FUNC
824 * @tc.require:
825 */
826 HWTEST_F(PointerEventTest, PointerEventTest_IsButtonPressed_001, TestSize.Level2)
827 {
828 CALL_TEST_DEBUG;
829 auto pointerEvent = PointerEvent::Create();
830 ASSERT_NE(pointerEvent, nullptr);
831 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
832 pointerEvent->SetPointerId(0);
833 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
834 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
835 pointerEvent->SetButtonPressed(0);
836 ASSERT_TRUE(pointerEvent->IsButtonPressed(0));
837 }
838
839 /**
840 * @tc.name: PointerEventTest_DeleteReleaseButton_001
841 * @tc.desc: Deletes a released button.
842 * @tc.type: FUNC
843 * @tc.require:
844 */
845 HWTEST_F(PointerEventTest, PointerEventTest_DeleteReleaseButton_001, TestSize.Level2)
846 {
847 CALL_TEST_DEBUG;
848 auto pointerEvent = PointerEvent::Create();
849 ASSERT_NE(pointerEvent, nullptr);
850 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
851 pointerEvent->SetPointerId(0);
852 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
853 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
854 pointerEvent->SetButtonPressed(0);
855 ASSERT_NO_FATAL_FAILURE(pointerEvent->DeleteReleaseButton(0));
856 std::set<int32_t> pressButtons = pointerEvent->GetPressedButtons();
857 ASSERT_EQ(pressButtons.size(), 0);
858 }
859
860 /**
861 * @tc.name: PointerEventTest_ClearButtonPressed_001
862 * @tc.desc: Clears the button in the pressed state.
863 * @tc.type: FUNC
864 * @tc.require:
865 */
866 HWTEST_F(PointerEventTest, PointerEventTest_ClearButtonPressed_001, TestSize.Level2)
867 {
868 CALL_TEST_DEBUG;
869 auto pointerEvent = PointerEvent::Create();
870 ASSERT_NE(pointerEvent, nullptr);
871 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
872 pointerEvent->SetPointerId(0);
873 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
874 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
875 pointerEvent->SetButtonPressed(0);
876 ASSERT_NO_FATAL_FAILURE(pointerEvent->ClearButtonPressed());
877 std::set<int32_t> pressButtons = pointerEvent->GetPressedButtons();
878 ASSERT_EQ(pressButtons.size(), 0);
879 }
880
881 /**
882 * @tc.name: PointerEventTest_ClearAxisValue_001
883 * @tc.desc: Clears the button in the pressed state.
884 * @tc.type: FUNC
885 * @tc.require:
886 */
887 HWTEST_F(PointerEventTest, PointerEventTest_ClearAxisValue_001, TestSize.Level2)
888 {
889 CALL_TEST_DEBUG;
890 auto pointerEvent = PointerEvent::Create();
891 ASSERT_NE(pointerEvent, nullptr);
892 pointerEvent->SetPointerId(0);
893 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, 30.0);
894 double axisValue = pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL);
895 ASSERT_EQ(axisValue, 30.0);
896 ASSERT_NO_FATAL_FAILURE(pointerEvent->ClearAxisValue());
897 ASSERT_EQ(pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL), 0);
898 }
899
900 /**
901 * @tc.name: PointerEventTest_SetZorderValue_001
902 * @tc.desc: Sets the zOrder for this event, inject to windows whose zOrder less than the target zOrder.
903 * @tc.type: FUNC
904 * @tc.require:
905 */
906 HWTEST_F(PointerEventTest, PointerEventTest_SetZorderValue_001, TestSize.Level2)
907 {
908 CALL_TEST_DEBUG;
909 auto pointerEvent = PointerEvent::Create();
910 ASSERT_NE(pointerEvent, nullptr);
911 pointerEvent->SetPointerId(0);
912 pointerEvent->SetZOrder(30.0);
913 float zOrder = pointerEvent->GetZOrder();
914 ASSERT_EQ(zOrder, 30.0);
915 }
916
917 /**
918 * @tc.name: PointerEventTest_IsValid_001
919 * @tc.desc: Checks whether this input event is valid.
920 * @tc.type: FUNC
921 * @tc.require:
922 */
923 HWTEST_F(PointerEventTest, PointerEventTest_IsValid_001, TestSize.Level2)
924 {
925 CALL_TEST_DEBUG;
926 auto pointerEvent = PointerEvent::Create();
927 ASSERT_NE(pointerEvent, nullptr);
928 pointerEvent->SetPointerId(0);
929 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
930 ASSERT_FALSE(pointerEvent->IsValid());
931 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
932 ASSERT_FALSE(pointerEvent->IsValid());
933 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
934 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
935 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
936 PointerEvent::PointerItem item;
937 item.SetPointerId(0);
938 item.SetDownTime(0);
939 item.SetPressed(false);
940 pointerEvent->AddPointerItem(item);
941 ASSERT_TRUE(pointerEvent->IsValid());
942 }
943
944 /**
945 * @tc.name: PointerEventTest_GetFingerCount_001
946 * @tc.desc: Sets the fingerCount for this event.
947 * @tc.type: FUNC
948 * @tc.require:
949 */
950 HWTEST_F(PointerEventTest, PointerEventTest_GetFingerCount_001, TestSize.Level2)
951 {
952 CALL_TEST_DEBUG;
953 auto pointerEvent = PointerEvent::Create();
954 ASSERT_NE(pointerEvent, nullptr);
955 pointerEvent->SetFingerCount(-12);
956 int32_t fingerCount = pointerEvent->GetFingerCount();
957 ASSERT_EQ(fingerCount, -12);
958 pointerEvent->SetFingerCount(-6);
959 fingerCount = pointerEvent->GetFingerCount();
960 ASSERT_EQ(fingerCount, -6);
961 pointerEvent->SetFingerCount(0);
962 fingerCount = pointerEvent->GetFingerCount();
963 ASSERT_EQ(fingerCount, 0);
964 pointerEvent->SetFingerCount(6);
965 fingerCount = pointerEvent->GetFingerCount();
966 ASSERT_EQ(fingerCount, 6);
967 pointerEvent->SetFingerCount(12);
968 fingerCount = pointerEvent->GetFingerCount();
969 ASSERT_EQ(fingerCount, 12);
970 }
971
972 /**
973 * @tc.name: PointerEventTest_ClearBuffer_001
974 * @tc.desc: Clear the buffer data.
975 * @tc.type: FUNC
976 * @tc.require:
977 */
978 HWTEST_F(PointerEventTest, PointerEventTest_ClearBuffer_001, TestSize.Level2)
979 {
980 CALL_TEST_DEBUG;
981 auto pointerEvent = PointerEvent::Create();
982 ASSERT_NE(pointerEvent, nullptr);
983 uint32_t enHanceDataLen = 3;
984 uint8_t enhanceDataBuf[enHanceDataLen];
985 std::vector<uint8_t> enhanceData;
986 for (uint32_t i = 0; i < enHanceDataLen; i++) {
987 enhanceData.push_back(enhanceDataBuf[i]);
988 }
989 pointerEvent->SetBuffer(enhanceData);
990 std::vector<uint8_t> buffer = pointerEvent->GetBuffer();
991 ASSERT_NE(buffer.size(), 0);
992 pointerEvent->ClearBuffer();
993 buffer = pointerEvent->GetBuffer();
994 ASSERT_EQ(buffer.size(), 0);
995 }
996
997 /**
998 * @tc.name: PointerEventTest_SetOriginPointerId_001
999 * @tc.desc: Sets the origin id of the pointer in this event.
1000 * @tc.type: FUNC
1001 * @tc.require:
1002 */
1003 HWTEST_F(PointerEventTest, PointerEventTest_SetOriginPointerId_001, TestSize.Level2)
1004 {
1005 CALL_TEST_DEBUG;
1006 int32_t originPointerId = 11;
1007 PointerEvent::PointerItem item;
1008 ASSERT_NO_FATAL_FAILURE(item.SetOriginPointerId(originPointerId));
1009 ASSERT_EQ(item.GetOriginPointerId(), originPointerId);
1010 }
1011
1012 /**
1013 * @tc.name: PointerEvent_PointerItem_GetTwist_001
1014 * @tc.desc: Test
1015 * @tc.type: FUNC
1016 * @tc.require:
1017 */
1018 HWTEST_F(PointerEventTest, PointerEvent_PointerItem_GetTwist_001, TestSize.Level2)
1019 {
1020 CALL_TEST_DEBUG;
1021 int32_t twist = 1;
1022 PointerEvent::PointerItem item;
1023 ASSERT_NO_FATAL_FAILURE(item.SetTwist(twist));
1024 ASSERT_EQ(item.GetTwist(), twist);
1025 }
1026
1027 /**
1028 * @tc.name: PointerEventTest_SetDisplayXPos_001
1029 * @tc.desc: Sets the x coordinate relative to the upper left corner of the screen.
1030 * @tc.type: FUNC
1031 * @tc.require:
1032 */
1033 HWTEST_F(PointerEventTest, PointerEventTest_SetDisplayXPos_001, TestSize.Level2)
1034 {
1035 CALL_TEST_DEBUG;
1036 double displayX = 10.0;
1037 PointerEvent::PointerItem item;
1038 ASSERT_NO_FATAL_FAILURE(item.SetDisplayXPos(displayX));
1039 ASSERT_EQ(item.GetDisplayXPos(), displayX);
1040 }
1041
1042 /**
1043 * @tc.name: PointerEventTest_SetDisplayYPos_001
1044 * @tc.desc: Sets the y coordinate relative to the upper left corner of the screen.
1045 * @tc.type: FUNC
1046 * @tc.require:
1047 */
1048 HWTEST_F(PointerEventTest, PointerEventTest_SetDisplayYPos_001, TestSize.Level2)
1049 {
1050 CALL_TEST_DEBUG;
1051 double displayY = 10.0;
1052 PointerEvent::PointerItem item;
1053 ASSERT_NO_FATAL_FAILURE(item.SetDisplayYPos(displayY));
1054 ASSERT_EQ(item.GetDisplayYPos(), displayY);
1055 }
1056
1057 /**
1058 * @tc.name: PointerEventTest_SetWindowXPos_001
1059 * @tc.desc: Sets the x coordinate of the active window.
1060 * @tc.type: FUNC
1061 * @tc.require:
1062 */
1063 HWTEST_F(PointerEventTest, PointerEventTest_SetWindowXPos_001, TestSize.Level2)
1064 {
1065 CALL_TEST_DEBUG;
1066 double x = 10.0;
1067 PointerEvent::PointerItem item;
1068 ASSERT_NO_FATAL_FAILURE(item.SetWindowXPos(x));
1069 ASSERT_EQ(item.GetWindowXPos(), x);
1070 }
1071
1072 /**
1073 * @tc.name: PointerEventTest_SetWindowYPos_001
1074 * @tc.desc: Sets the y coordinate of the active window.
1075 * @tc.type: FUNC
1076 * @tc.require:
1077 */
1078 HWTEST_F(PointerEventTest, PointerEventTest_SetWindowYPos_001, TestSize.Level2)
1079 {
1080 CALL_TEST_DEBUG;
1081 double y = 10.0;
1082 PointerEvent::PointerItem item;
1083 ASSERT_NO_FATAL_FAILURE(item.SetWindowYPos(y));
1084 ASSERT_EQ(item.GetWindowYPos(), y);
1085 }
1086
1087 /**
1088 * @tc.name: PointerEventTest_ActionToShortStr_001
1089 * @tc.desc: Verify ActionToShortStr
1090 * @tc.type: FUNC
1091 * @tc.require:
1092 * @tc.author:
1093 */
1094 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_001, TestSize.Level2)
1095 {
1096 CALL_TEST_DEBUG;
1097 int32_t eventType = 1;
1098 AxisEvent axisevent(eventType);
1099 int32_t action = AxisEvent::AXIS_ACTION_CANCEL;
1100 auto ret = axisevent.ActionToShortStr(action);
1101 ASSERT_EQ(ret, "A:C:");
1102 action = AxisEvent::AXIS_ACTION_START;
1103 ret = axisevent.ActionToShortStr(action);
1104 ASSERT_EQ(ret, "A:S:");
1105 action = AxisEvent::AXIS_ACTION_UPDATE;
1106 ret = axisevent.ActionToShortStr(action);
1107 ASSERT_EQ(ret, "A:U:");
1108 action = AxisEvent::AXIS_ACTION_END;
1109 ret = axisevent.ActionToShortStr(action);
1110 ASSERT_EQ(ret, "A:E:");
1111 action = AxisEvent::AXIS_ACTION_UNKNOWN;
1112 ret = axisevent.ActionToShortStr(action);
1113 ASSERT_EQ(ret, "A:UK:");
1114 action = 10;
1115 ret = axisevent.ActionToShortStr(action);
1116 ASSERT_EQ(ret, "A:?:");
1117 }
1118
1119 /**
1120 * @tc.name: PointerEventTest_AddCapability_001
1121 * @tc.desc: Verify AddCapability
1122 * @tc.type: FUNC
1123 * @tc.require:
1124 * @tc.author:
1125 */
1126 HWTEST_F(PointerEventTest, PointerEventTest_AddCapability_001, TestSize.Level2)
1127 {
1128 CALL_TEST_DEBUG;
1129 InputDevice device;
1130 InputDeviceCapability cap;
1131 cap = INPUT_DEV_CAP_TOUCH;
1132 ASSERT_NO_FATAL_FAILURE(device.AddCapability(cap));
1133 cap = INPUT_DEV_CAP_MAX;
1134 ASSERT_NO_FATAL_FAILURE(device.AddCapability(cap));
1135 }
1136
1137 /**
1138 * @tc.name: PointerEventTest_HasCapability_001
1139 * @tc.desc: Verify HasCapability
1140 * @tc.type: FUNC
1141 * @tc.require:
1142 * @tc.author:
1143 */
1144 HWTEST_F(PointerEventTest, PointerEventTest_HasCapability_001, TestSize.Level2)
1145 {
1146 CALL_TEST_DEBUG;
1147 InputDevice device;
1148 InputDeviceCapability cap;
1149 cap = INPUT_DEV_CAP_TOUCH;
1150 bool ret = device.HasCapability(cap);
1151 ASSERT_FALSE(ret);
1152 cap = INPUT_DEV_CAP_MAX;
1153 ret = device.HasCapability(cap);
1154 ASSERT_FALSE(ret);
1155 }
1156
1157 /**
1158 * @tc.name: PointerEventTest_HasCapability_002
1159 * @tc.desc: Verify HasCapability
1160 * @tc.type: FUNC
1161 * @tc.require:
1162 * @tc.author:
1163 */
1164 HWTEST_F(PointerEventTest, PointerEventTest_HasCapability_002, TestSize.Level2)
1165 {
1166 CALL_TEST_DEBUG;
1167 InputDevice device;
1168 device.capabilities_.set(InputDeviceCapability::INPUT_DEV_CAP_KEYBOARD);
1169 device.capabilities_.set(InputDeviceCapability::INPUT_DEV_CAP_POINTER);
1170 EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD));
1171 EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_POINTER));
1172 EXPECT_FALSE(device.HasCapability(INPUT_DEV_CAP_TOUCH));
1173 EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD | INPUT_DEV_CAP_POINTER | INPUT_DEV_CAP_TOUCH));
1174 EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD | INPUT_DEV_CAP_POINTER));
1175 }
1176
1177 /**
1178 * @tc.name: PointerEventTest_MarkProcessed_001
1179 * @tc.desc: Verify MarkProcessed
1180 * @tc.type: FUNC
1181 * @tc.require:
1182 * @tc.author:
1183 */
1184 HWTEST_F(PointerEventTest, PointerEventTest_MarkProcessed_001, TestSize.Level2)
1185 {
1186 CALL_TEST_DEBUG;
1187 std::function<void(int32_t, int64_t)> processedCallback_;
1188 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1189 inputEvent->markEnabled_ = true;
1190 ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1191 inputEvent->markEnabled_ = false;
1192 ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1193 }
1194
1195 /**
1196 * @tc.name: PointerEventTest_SetExtraData_002
1197 * @tc.desc: Verify SetExtraData
1198 * @tc.type: FUNC
1199 * @tc.require:
1200 * @tc.author:
1201 */
1202 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_002, TestSize.Level2)
1203 {
1204 CALL_TEST_DEBUG;
1205 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1206 std::shared_ptr<const uint8_t[]> data;
1207 uint32_t length = 10;
1208 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(data, length));
1209 }
1210
1211 /**
1212 * @tc.name: PointerEventTest_GetExtraData_002
1213 * @tc.desc: Verify GetExtraData
1214 * @tc.type: FUNC
1215 * @tc.require:
1216 * @tc.author:
1217 */
1218 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_002, TestSize.Level2)
1219 {
1220 CALL_TEST_DEBUG;
1221 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1222 std::shared_ptr<const uint8_t[]> data;
1223 uint32_t length = 10;
1224 inputEvent->extraDataLength_ = 5;
1225 std::shared_ptr<const uint8_t[]> extraData;
1226 inputEvent->extraData_ = extraData;
1227 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1228 }
1229
1230 /**
1231 * @tc.name: PointerEventTest_WriteToParcel_001
1232 * @tc.desc: Verify WriteToParcel
1233 * @tc.type: FUNC
1234 * @tc.require:
1235 * @tc.author:
1236 */
1237 HWTEST_F(PointerEventTest, PointerEventTest_WriteToParcel_001, TestSize.Level2)
1238 {
1239 CALL_TEST_DEBUG;
1240 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1241 Parcel out;
1242 inputEvent->extraDataLength_ = 5;
1243 std::shared_ptr<const uint8_t[]> extraData;
1244 inputEvent->extraData_ = extraData;
1245 bool ret = inputEvent->WriteToParcel(out);
1246 ASSERT_TRUE(ret);
1247 }
1248
1249 /**
1250 * @tc.name: PointerEventTest_ReadFromParcel_001
1251 * @tc.desc: Verify ReadFromParcel
1252 * @tc.type: FUNC
1253 * @tc.require:
1254 * @tc.author:
1255 */
1256 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel_001, TestSize.Level2)
1257 {
1258 CALL_TEST_DEBUG;
1259 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1260 Parcel in;
1261 inputEvent->extraDataLength_ = 1088;
1262 bool ret = inputEvent->ReadFromParcel(in);
1263 ASSERT_FALSE(ret);
1264 inputEvent->extraDataLength_ = 10;
1265 ret = inputEvent->ReadFromParcel(in);
1266 ASSERT_FALSE(ret);
1267 }
1268
1269 /**
1270 * @tc.name: PointerEventTest_ActionToShortStr_002
1271 * @tc.desc: Verify ActionToShortStr
1272 * @tc.type: FUNC
1273 * @tc.require:
1274 * @tc.author:
1275 */
1276 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_002, TestSize.Level2)
1277 {
1278 CALL_TEST_DEBUG;
1279 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1280 int32_t action = InputEvent::ACTION_CANCEL;
1281 auto ret = inputEvent->ActionToShortStr(action);
1282 ASSERT_EQ(ret, "B:C:");
1283 action = InputEvent::ACTION_UNKNOWN;
1284 ret = inputEvent->ActionToShortStr(action);
1285 ASSERT_EQ(ret, "B:UK:");
1286 action = InputEvent::EVENT_FLAG_HIDE_POINTER;
1287 ret = inputEvent->ActionToShortStr(action);
1288 ASSERT_EQ(ret, "B:?:");
1289 }
1290
1291 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
1292 /**
1293 * @tc.name: PointerEventTest_SetFingerprintDistanceX_001
1294 * @tc.desc: Set the fingerprint distance X.
1295 * @tc.type: FUNC
1296 * @tc.require:
1297 */
1298 HWTEST_F(PointerEventTest, PointerEventTest_SetFingerprintDistanceX_001, TestSize.Level2)
1299 {
1300 CALL_TEST_DEBUG;
1301 auto pointerEvent = PointerEvent::Create();
1302 ASSERT_NE(pointerEvent, nullptr);
1303 double x = 10.0;
1304 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetFingerprintDistanceX(x));
1305 ASSERT_EQ(pointerEvent->GetFingerprintDistanceX(), x);
1306 }
1307
1308 /**
1309 * @tc.name: PointerEventTest_SetFingerprintDistanceY_001
1310 * @tc.desc: Set the fingerprint distance Y.
1311 * @tc.type: FUNC
1312 * @tc.require:
1313 */
1314 HWTEST_F(PointerEventTest, PointerEventTest_SetFingerprintDistanceY_001, TestSize.Level2)
1315 {
1316 CALL_TEST_DEBUG;
1317 auto pointerEvent = PointerEvent::Create();
1318 ASSERT_NE(pointerEvent, nullptr);
1319 double y = 10.0;
1320 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetFingerprintDistanceY(y));
1321 ASSERT_EQ(pointerEvent->GetFingerprintDistanceY(), y);
1322 }
1323 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
1324
1325 /**
1326 * @tc.name: PointerEventTest_SetHandlerEventType
1327 * @tc.desc: Verify SetHandlerEventType
1328 * @tc.type: FUNC
1329 * @tc.require:
1330 * @tc.author:
1331 */
1332 HWTEST_F(PointerEventTest, PointerEventTest_SetHandlerEventType, TestSize.Level2)
1333 {
1334 CALL_TEST_DEBUG;
1335 auto pointerEvent = PointerEvent::Create();
1336 ASSERT_NE(pointerEvent, nullptr);
1337 pointerEvent->SetHandlerEventType(0);
1338 ASSERT_EQ(pointerEvent->GetHandlerEventType(), 0);
1339 }
1340
1341 /**
1342 * @tc.name: PointerEventTest_GetAxisValue_001
1343 * @tc.desc: Test the funcation GetAxisValue
1344 * @tc.type: FUNC
1345 * @tc.require:
1346 */
1347 HWTEST_F(PointerEventTest, PointerEventTest_GetAxisValue_001, TestSize.Level2)
1348 {
1349 CALL_TEST_DEBUG;
1350 auto pointerEvent = PointerEvent::Create();
1351 ASSERT_NE(pointerEvent, nullptr);
1352 PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1353 ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1354 axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1355 ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1356 axis = PointerEvent::AXIS_TYPE_PINCH;
1357 ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1358 }
1359
1360 /**
1361 * @tc.name: PointerEventTest_SetAxisValue_001
1362 * @tc.desc: Test the funcation SetAxisValue
1363 * @tc.type: FUNC
1364 * @tc.require:
1365 */
1366 HWTEST_F(PointerEventTest, PointerEventTest_SetAxisValue_001, TestSize.Level2)
1367 {
1368 CALL_TEST_DEBUG;
1369 auto pointerEvent = PointerEvent::Create();
1370 ASSERT_NE(pointerEvent, nullptr);
1371 double axisValue = 1.0;
1372 PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1373 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1374 axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1375 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1376 axis = PointerEvent::AXIS_TYPE_PINCH;
1377 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1378 }
1379
1380 /**
1381 * @tc.name: PointerEventTest_HasAxis_001
1382 * @tc.desc: Test the funcation HasAxis
1383 * @tc.type: FUNC
1384 * @tc.require:
1385 */
1386 HWTEST_F(PointerEventTest, PointerEventTest_HasAxis_001, TestSize.Level2)
1387 {
1388 CALL_TEST_DEBUG;
1389 auto pointerEvent = PointerEvent::Create();
1390 ASSERT_NE(pointerEvent, nullptr);
1391 uint32_t axes = 1;
1392 PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1393 bool ret = pointerEvent->HasAxis(axes, axis);
1394 ASSERT_FALSE(ret);
1395 axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1396 ret = pointerEvent->HasAxis(axes, axis);
1397 ASSERT_TRUE(ret);
1398 axis = PointerEvent::AXIS_TYPE_PINCH;
1399 ret = pointerEvent->HasAxis(axes, axis);
1400 ASSERT_FALSE(ret);
1401 }
1402
1403 /**
1404 * @tc.name: PointerEventTest_SetPressure_001
1405 * @tc.desc: Test the funcation SetPressure
1406 * @tc.type: FUNC
1407 * @tc.require:
1408 */
1409 HWTEST_F(PointerEventTest, PointerEventTest_SetPressure_001, TestSize.Level2)
1410 {
1411 CALL_TEST_DEBUG;
1412 double pressure = -1.0;
1413 PointerEvent::PointerItem item;
1414 ASSERT_NO_FATAL_FAILURE(item.SetPressure(pressure));
1415 pressure = 1.0;
1416 ASSERT_NO_FATAL_FAILURE(item.SetPressure(pressure));
1417 }
1418
1419 /**
1420 * @tc.name: PointerEventTest_SetMoveFlag_001
1421 * @tc.desc: Test the funcation SetMoveFlag
1422 * @tc.type: FUNC
1423 * @tc.require:
1424 */
1425 HWTEST_F(PointerEventTest, PointerEventTest_SetMoveFlag_001, TestSize.Level2)
1426 {
1427 CALL_TEST_DEBUG;
1428 int32_t moveFlag = -1;
1429 PointerEvent::PointerItem item;
1430 ASSERT_NO_FATAL_FAILURE(item.SetMoveFlag(moveFlag));
1431 moveFlag = 0;
1432 ASSERT_NO_FATAL_FAILURE(item.SetMoveFlag(moveFlag));
1433 }
1434
1435 /**
1436 * @tc.name: PointerEventTest_ActionToShortStr_003
1437 * @tc.desc: Test the funcation ActionToShortStr
1438 * @tc.type: FUNC
1439 * @tc.require:
1440 */
1441 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_003, TestSize.Level2)
1442 {
1443 CALL_TEST_DEBUG;
1444 auto pointerEvent = PointerEvent::Create();
1445 ASSERT_NE(pointerEvent, nullptr);
1446 int32_t action = PointerEvent::POINTER_ACTION_PULL_UP;
1447 auto ret = pointerEvent->ActionToShortStr(action);
1448 ASSERT_EQ(ret, "P:PU:");
1449 action = PointerEvent::POINTER_ACTION_PULL_IN_WINDOW;
1450 ret = pointerEvent->ActionToShortStr(action);
1451 ASSERT_EQ(ret, "P:PI:");
1452 action = PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW;
1453 ret = pointerEvent->ActionToShortStr(action);
1454 ASSERT_EQ(ret, "P:PO:");
1455 action = PointerEvent::POINTER_ACTION_SWIPE_BEGIN;
1456 ret = pointerEvent->ActionToShortStr(action);
1457 ASSERT_EQ(ret, "P:SB:");
1458 action = PointerEvent::POINTER_ACTION_SWIPE_UPDATE;
1459 ret = pointerEvent->ActionToShortStr(action);
1460 ASSERT_EQ(ret, "P:SU:");
1461 action = PointerEvent::POINTER_ACTION_SWIPE_END;
1462 ret = pointerEvent->ActionToShortStr(action);
1463 ASSERT_EQ(ret, "P:SE:");
1464 action = PointerEvent::POINTER_ACTION_ROTATE_BEGIN;
1465 ret = pointerEvent->ActionToShortStr(action);
1466 ASSERT_EQ(ret, "P:RB:");
1467 action = PointerEvent::POINTER_ACTION_ROTATE_UPDATE;
1468 ret = pointerEvent->ActionToShortStr(action);
1469 ASSERT_EQ(ret, "P:RU:");
1470 action = PointerEvent::POINTER_ACTION_ROTATE_END;
1471 ret = pointerEvent->ActionToShortStr(action);
1472 ASSERT_EQ(ret, "P:RE:");
1473 action = PointerEvent::POINTER_ACTION_TRIPTAP;
1474 ret = pointerEvent->ActionToShortStr(action);
1475 ASSERT_EQ(ret, "P:TT:");
1476 }
1477
1478 /**
1479 * @tc.name: PointerEventTest_ActionToShortStr_004
1480 * @tc.desc: Test the funcation ActionToShortStr
1481 * @tc.type: FUNC
1482 * @tc.require:
1483 */
1484 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_004, TestSize.Level2)
1485 {
1486 CALL_TEST_DEBUG;
1487 auto pointerEvent = PointerEvent::Create();
1488 ASSERT_NE(pointerEvent, nullptr);
1489 int32_t action = PointerEvent::POINTER_ACTION_QUADTAP;
1490 auto ret = pointerEvent->ActionToShortStr(action);
1491 ASSERT_EQ(ret, "P:Q:");
1492 action = PointerEvent::POINTER_ACTION_HOVER_MOVE;
1493 ret = pointerEvent->ActionToShortStr(action);
1494 ASSERT_EQ(ret, "P:HM:");
1495 action = PointerEvent::POINTER_ACTION_HOVER_ENTER;
1496 ret = pointerEvent->ActionToShortStr(action);
1497 ASSERT_EQ(ret, "P:HE:");
1498 action = PointerEvent::POINTER_ACTION_FINGERPRINT_DOWN;
1499 ret = pointerEvent->ActionToShortStr(action);
1500 ASSERT_EQ(ret, "P:FD:");
1501 action = PointerEvent::POINTER_ACTION_FINGERPRINT_UP;
1502 ret = pointerEvent->ActionToShortStr(action);
1503 ASSERT_EQ(ret, "P:FU:");
1504 action = PointerEvent::POINTER_ACTION_FINGERPRINT_SLIDE;
1505 ret = pointerEvent->ActionToShortStr(action);
1506 ASSERT_EQ(ret, "P:FS:");
1507 action = PointerEvent::POINTER_ACTION_FINGERPRINT_RETOUCH;
1508 ret = pointerEvent->ActionToShortStr(action);
1509 ASSERT_EQ(ret, "P:FR:");
1510 action = PointerEvent::POINTER_ACTION_FINGERPRINT_CLICK;
1511 ret = pointerEvent->ActionToShortStr(action);
1512 ASSERT_EQ(ret, "P:FC:");
1513 action = PointerEvent::POINTER_ACTION_UNKNOWN;
1514 ret = pointerEvent->ActionToShortStr(action);
1515 ASSERT_EQ(ret, "P:UK:");
1516 action = 100;
1517 ret = pointerEvent->ActionToShortStr(action);
1518 ASSERT_EQ(ret, "P:?:");
1519 }
1520
1521 /**
1522 * @tc.name: PointerEventTest_SetTiltX_001
1523 * @tc.desc: Test the funcation SetTiltX and GetTiltX
1524 * @tc.type: FUNC
1525 * @tc.require:
1526 */
1527 HWTEST_F(PointerEventTest, PointerEventTest_SetTiltX_001, TestSize.Level2)
1528 {
1529 CALL_TEST_DEBUG;
1530 double x = 10.0;
1531 PointerEvent::PointerItem item;
1532 ASSERT_NO_FATAL_FAILURE(item.SetTiltX(x));
1533 ASSERT_EQ(item.GetTiltX(), x);
1534 }
1535
1536 /**
1537 * @tc.name: PointerEventTest_SetTiltY_001
1538 * @tc.desc: Test the funcation SetTiltY and GetTiltY
1539 * @tc.type: FUNC
1540 * @tc.require:
1541 */
1542 HWTEST_F(PointerEventTest, PointerEventTest_SetTiltY_001, TestSize.Level2)
1543 {
1544 CALL_TEST_DEBUG;
1545 double y = 10.0;
1546 PointerEvent::PointerItem item;
1547 ASSERT_NO_FATAL_FAILURE(item.SetTiltY(y));
1548 ASSERT_EQ(item.GetTiltY(), y);
1549 }
1550
1551 /**
1552 * @tc.name: PointerEventTest_SetRawDisplayX_001
1553 * @tc.desc: Sets the raw X coordinate.
1554 * @tc.type: FUNC
1555 * @tc.require:
1556 */
1557 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDisplayX_001, TestSize.Level2)
1558 {
1559 CALL_TEST_DEBUG;
1560 int32_t rawDisplayX = 60;
1561 PointerEvent::PointerItem item;
1562 item.SetPointerId(8);
1563 item.SetDownTime(1);
1564 ASSERT_NO_FATAL_FAILURE(item.SetRawDisplayX(rawDisplayX));
1565 ASSERT_EQ(item.GetRawDisplayX(), rawDisplayX);
1566 }
1567
1568 /**
1569 * @tc.name: PointerEventTest_SetRawDisplayY_001
1570 * @tc.desc: Sets the raw Y coordinate.
1571 * @tc.type: FUNC
1572 * @tc.require:
1573 */
1574 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDisplayY_001, TestSize.Level2)
1575 {
1576 CALL_TEST_DEBUG;
1577 int32_t rawDisplayY = 60;
1578 PointerEvent::PointerItem item;
1579 item.SetPointerId(8);
1580 item.SetDownTime(1);
1581 ASSERT_NO_FATAL_FAILURE(item.SetRawDisplayY(rawDisplayY));
1582 ASSERT_EQ(item.GetRawDisplayY(), rawDisplayY);
1583 }
1584
1585 /**
1586 * @tc.name: PointerEventTest_EventTypeToString_001
1587 * @tc.desc: Test the funcation EventTypeToString
1588 * @tc.type: FUNC
1589 * @tc.require:
1590 */
1591 HWTEST_F(PointerEventTest, PointerEventTest_EventTypeToString_001, TestSize.Level2)
1592 {
1593 CALL_TEST_DEBUG;
1594 auto inputEvent = InputEvent::Create();
1595 ASSERT_NE(inputEvent, nullptr);
1596 int32_t eventType = InputEvent::EVENT_TYPE_BASE;
1597 std::string ret = inputEvent->EventTypeToString(eventType);
1598 ASSERT_EQ(ret, "base");
1599 eventType = InputEvent::EVENT_TYPE_KEY;
1600 ret = inputEvent->EventTypeToString(eventType);
1601 ASSERT_EQ(ret, "key");
1602 eventType = InputEvent::EVENT_TYPE_POINTER;
1603 ret = inputEvent->EventTypeToString(eventType);
1604 ASSERT_EQ(ret, "pointer");
1605 eventType = InputEvent::EVENT_TYPE_AXIS;
1606 ret = inputEvent->EventTypeToString(eventType);
1607 ASSERT_EQ(ret, "axis");
1608 eventType = InputEvent::EVENT_TYPE_FINGERPRINT;
1609 ret = inputEvent->EventTypeToString(eventType);
1610 ASSERT_EQ(ret, "fingerprint");
1611 eventType = InputEvent::EVENT_FLAG_NO_INTERCEPT;
1612 ret = inputEvent->EventTypeToString(eventType);
1613 ASSERT_EQ(ret, "unknown");
1614 }
1615
1616 /**
1617 * @tc.name: PointerEventTest_MarkProcessed_002
1618 * @tc.desc: Test the funcation MarkProcessed
1619 * @tc.type: FUNC
1620 * @tc.require:
1621 * @tc.author:
1622 */
1623 HWTEST_F(PointerEventTest, PointerEventTest_MarkProcessed_002, TestSize.Level2)
1624 {
1625 CALL_TEST_DEBUG;
1626 auto inputEvent = InputEvent::Create();
1627 ASSERT_NE(inputEvent, nullptr);
__anone312930d0202(int a, int b) 1628 auto callback = [](int a, int b) {};
1629 inputEvent->processedCallback_ = callback;
1630 inputEvent->processedCallback_(10, 20);
1631 inputEvent->markEnabled_ = false;
1632 ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1633 inputEvent->markEnabled_ = true;
1634 ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1635 }
1636
1637 /**
1638 * @tc.name: PointerEventTest_SetExtraData_005
1639 * @tc.desc: Set extra data
1640 * @tc.type: FUNC
1641 * @tc.require:
1642 */
1643 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_005, TestSize.Level2)
1644 {
1645 CALL_TEST_DEBUG;
1646 auto inputEvent = InputEvent::Create();
1647 ASSERT_NE(inputEvent, nullptr);
1648 uint32_t length = 5;
1649 uint8_t data[5] = {1, 2, 3, 4, 5};
__anone312930d0302(const uint8_t*) 1650 std::shared_ptr<const uint8_t[]> sharedData(data, [](const uint8_t*) {});
1651 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1652 length = -5;
1653 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1654 length = 2000;
1655 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1656 }
1657
1658 /**
1659 * @tc.name: PointerEventTest_GetExtraData_004
1660 * @tc.desc: Verify GetExtraData
1661 * @tc.type: FUNC
1662 * @tc.require:
1663 * @tc.author:
1664 */
1665 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_004, TestSize.Level2)
1666 {
1667 CALL_TEST_DEBUG;
1668 auto inputEvent = InputEvent::Create();
1669 ASSERT_NE(inputEvent, nullptr);
1670 uint32_t length = 5;
1671 inputEvent->extraDataLength_ = 5;
1672 std::shared_ptr<const uint8_t[]> data;
1673 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1674 inputEvent->extraDataLength_ = 0;
1675 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1676 uint8_t datas[5] = {1, 2, 3, 4, 5};
__anone312930d0402(const uint8_t*) 1677 std::shared_ptr<const uint8_t[]> sharedData(datas, [](const uint8_t*) {});
1678 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1679 inputEvent->extraDataLength_ = 10;
1680 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1681 inputEvent->extraDataLength_ = 0;
1682 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1683 }
1684
1685 /**
1686 * @tc.name: PointerEventTest_WriteToParcel_003
1687 * @tc.desc: Verify WriteToParcel
1688 * @tc.type: FUNC
1689 * @tc.require:
1690 * @tc.author:
1691 */
1692 HWTEST_F(PointerEventTest, PointerEventTest_WriteToParcel_003, TestSize.Level2)
1693 {
1694 CALL_TEST_DEBUG;
1695 auto inputEvent = InputEvent::Create();
1696 ASSERT_NE(inputEvent, nullptr);
1697 Parcel out;
1698 uint32_t length = 5;
1699 inputEvent->extraDataLength_ = 0;
1700 bool ret = inputEvent->WriteToParcel(out);
1701 ASSERT_TRUE(ret);
1702 inputEvent->extraDataLength_ = 5;
1703 ret = inputEvent->WriteToParcel(out);
1704 ASSERT_TRUE(ret);
1705 uint8_t datas[5] = {1, 2, 3, 4, 5};
__anone312930d0502(const uint8_t*) 1706 std::shared_ptr<const uint8_t[]> sharedData(datas, [](const uint8_t*) {});
1707 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1708 inputEvent->extraDataLength_ = 0;
1709 ret = inputEvent->WriteToParcel(out);
1710 ASSERT_TRUE(ret);
1711 inputEvent->extraDataLength_ = 5;
1712 ret = inputEvent->WriteToParcel(out);
1713 ASSERT_TRUE(ret);
1714 }
1715
1716 /**
1717 * @tc.name: PointerEventTest_ToString
1718 * @tc.desc: Test the funcation ToString
1719 * @tc.type: FUNC
1720 * @tc.require:
1721 */
1722 HWTEST_F(PointerEventTest, PointerEventTest_ToString, TestSize.Level2)
1723 {
1724 CALL_TEST_DEBUG;
1725 auto pointerEvent = PointerEvent::Create();
1726 ASSERT_NE(pointerEvent, nullptr);
1727 ASSERT_NO_FATAL_FAILURE(pointerEvent->ToString());
1728
1729 auto inputEvent = InputEvent::Create();
1730 ASSERT_NE(inputEvent, nullptr);
1731 ASSERT_NO_FATAL_FAILURE(inputEvent->ToString());
1732 }
1733
1734 /**
1735 * @tc.name: PointerEventTest_ReadFromParcel
1736 * @tc.desc: Test the funcation ReadFromParcel
1737 * @tc.type: FUNC
1738 * @tc.require:
1739 */
1740 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel, TestSize.Level2)
1741 {
1742 CALL_TEST_DEBUG;
1743 Parcel in;
1744 PointerEvent::PointerItem item;
1745 item.pressed_ = false;
1746 bool ret = item.ReadFromParcel(in);
1747 ASSERT_FALSE(ret);
1748 }
1749
1750 /**
1751 * @tc.name: PointerEventTest_ClearAxisStatus
1752 * @tc.desc: Test the funcation ClearAxisStatus
1753 * @tc.type: FUNC
1754 * @tc.require:
1755 */
1756 HWTEST_F(PointerEventTest, PointerEventTest_ClearAxisStatus, TestSize.Level2)
1757 {
1758 CALL_TEST_DEBUG;
1759 auto pointerEvent = PointerEvent::Create();
1760 ASSERT_NE(pointerEvent, nullptr);
1761 PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1762 ASSERT_NO_FATAL_FAILURE(pointerEvent->ClearAxisStatus(axis));
1763 }
1764
1765 /**
1766 * @tc.name: PointerEventTest_from
1767 * @tc.desc: Verify the funcation from
1768 * @tc.type: FUNC
1769 * @tc.require:
1770 * @tc.author:
1771 */
1772 HWTEST_F(PointerEventTest, PointerEventTest_from, TestSize.Level2)
1773 {
1774 CALL_TEST_DEBUG;
1775 auto inputEvent = InputEvent::Create();
1776 ASSERT_NE(inputEvent, nullptr);
1777 ASSERT_NO_FATAL_FAILURE(PointerEvent::from(inputEvent));
1778 }
1779
1780 /**
1781 * @tc.name: PointerEventTest_GetBlobId
1782 * @tc.desc: Verify the funcation GetBlobId
1783 * @tc.type: FUNC
1784 * @tc.require:
1785 * @tc.author:
1786 */
1787 HWTEST_F(PointerEventTest, PointerEventTest_GetBlobId, TestSize.Level2)
1788 {
1789 CALL_TEST_DEBUG;
1790 auto inputEvent = InputEvent::Create();
1791 ASSERT_NE(inputEvent, nullptr);
1792 auto item = PointerEvent::PointerItem();
1793 item.blobId_ = 0;
1794 int32_t bloBid = item.GetBlobId();
1795 ASSERT_EQ(bloBid, item.blobId_);
1796 }
1797
1798 /**
1799 * @tc.name: PointerEventTest_SetBlobId
1800 * @tc.desc: Verify the funcation SetBlobId
1801 * @tc.type: FUNC
1802 * @tc.require:
1803 * @tc.author:
1804 */
1805 HWTEST_F(PointerEventTest, PointerEventTest_SetBlobId, TestSize.Level2)
1806 {
1807 CALL_TEST_DEBUG;
1808 auto inputEvent = InputEvent::Create();
1809 ASSERT_NE(inputEvent, nullptr);
1810 auto item = PointerEvent::PointerItem();
1811 item.SetBlobId(32);
1812 ASSERT_EQ(32, item.blobId_);
1813 }
1814
1815 /**
1816 * @tc.name: PointerEventTest_IsCanceled
1817 * @tc.desc: Verify the funcation IsCanceled
1818 * @tc.type: FUNC
1819 * @tc.require:
1820 * @tc.author:
1821 */
1822 HWTEST_F(PointerEventTest, PointerEventTest_IsCanceled, TestSize.Level2)
1823 {
1824 CALL_TEST_DEBUG;
1825 auto item = PointerEvent::PointerItem();
1826 item.SetCanceled(true);
1827 ASSERT_TRUE(item.IsCanceled());
1828 }
1829
1830 /**
1831 * @tc.name: PointerEventTest_GetFixedDisplayX
1832 * @tc.desc: Verify the funcation FixedDisplayX
1833 * @tc.type: FUNC
1834 * @tc.require:
1835 * @tc.author:
1836 */
1837 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedDisplayX, TestSize.Level2)
1838 {
1839 CALL_TEST_DEBUG;
1840 auto item = PointerEvent::PointerItem();
1841 int32_t disPlayX = 25;
1842 item.SetFixedDisplayX(disPlayX);
1843 ASSERT_EQ(item.GetFixedDisplayX(), disPlayX);
1844 }
1845
1846 /**
1847 * @tc.name: PointerEventTest_GetFixedDisplayXPosTouchScreen
1848 * @tc.desc: Verify the funcation PointerEventTest_GetFixedDisplayXPosTouchScreen
1849 * @tc.type: FUNC
1850 * @tc.require:
1851 * @tc.author:
1852 */
1853 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedDisplayXPosTouchScreen, TestSize.Level2)
1854 {
1855 CALL_TEST_DEBUG;
1856 auto pointerEvent = PointerEvent::Create();
1857 ASSERT_NE(pointerEvent, nullptr);
1858 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1859 pointerEvent->SetPointerId(0);
1860 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1861 PointerEvent::PointerItem pointerItem1;
1862 int32_t disPlayX1 = 100;
1863 int32_t disPlayY1 = 110;
1864 pointerItem1.SetFixedDisplayXPos(disPlayX1);
1865 pointerItem1.SetFixedDisplayYPos(disPlayY1);
1866 pointerItem1.SetPointerId(0);
1867 pointerItem1.SetDownTime(0);
1868 pointerItem1.SetPressed(true);
1869 pointerItem1.SetPressure(30);
1870 pointerItem1.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
1871 pointerEvent->AddPointerItem(pointerItem1);
1872 PointerEvent::PointerItem pointerItem2;
1873 int32_t disPlayX2 = 200;
1874 int32_t disPlayY2 = 220;
1875 pointerItem2.SetFixedDisplayXPos(disPlayX2);
1876 pointerItem2.SetFixedDisplayYPos(disPlayY2);
1877 pointerItem2.SetPointerId(1);
1878 pointerItem2.SetDownTime(0);
1879 pointerItem2.SetPressed(true);
1880 pointerItem2.SetPressure(30);
1881 pointerItem2.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
1882 pointerEvent->AddPointerItem(pointerItem2);
1883 PointerEvent::PointerItem pointerItemRes1;
1884 pointerEvent->GetPointerItem(0, pointerItemRes1);
1885 ASSERT_EQ(pointerItemRes1.GetFixedDisplayXPos(), disPlayX1);
1886 ASSERT_EQ(pointerItemRes1.GetFixedDisplayYPos(), disPlayY1);
1887 PointerEvent::PointerItem pointerItemRes2;
1888 pointerEvent->GetPointerItem(1, pointerItemRes2);
1889 ASSERT_EQ(pointerItemRes2.GetFixedDisplayXPos(), disPlayX2);
1890 ASSERT_EQ(pointerItemRes2.GetFixedDisplayYPos(), disPlayY2);
1891 }
1892
1893 /**
1894 * @tc.name: PointerEventTest_GetFixedDisplayXPosMouse
1895 * @tc.desc: Verify the funcation PointerEventTest_GetFixedDisplayXPosMouse
1896 * @tc.type: FUNC
1897 * @tc.require:
1898 * @tc.author:
1899 */
1900 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedDisplayXPosMouse, TestSize.Level2)
1901 {
1902 CALL_TEST_DEBUG;
1903 auto pointerEvent = PointerEvent::Create();
1904 ASSERT_NE(pointerEvent, nullptr);
1905 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
1906 pointerEvent->SetPointerId(0);
1907 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1908 PointerEvent::PointerItem pointerItem1;
1909 int32_t disPlayX1 = 100;
1910 int32_t disPlayY1 = 110;
1911 pointerItem1.SetFixedDisplayXPos(disPlayX1);
1912 pointerItem1.SetFixedDisplayYPos(disPlayY1);
1913 pointerItem1.SetPointerId(0);
1914 pointerItem1.SetDownTime(0);
1915 pointerItem1.SetPressed(true);
1916 pointerItem1.SetPressure(30);
1917 pointerItem1.SetToolType(PointerEvent::TOOL_TYPE_MOUSE);
1918 pointerEvent->AddPointerItem(pointerItem1);
1919 PointerEvent::PointerItem pointerItemRes1;
1920 pointerEvent->GetPointerItem(0, pointerItemRes1);
1921 ASSERT_EQ(pointerItemRes1.GetFixedDisplayXPos(), disPlayX1);
1922 ASSERT_EQ(pointerItemRes1.GetFixedDisplayYPos(), disPlayY1);
1923 }
1924
1925 /**
1926 * @tc.name: PointerEventTest_GetFixedDisplayXPosPen
1927 * @tc.desc: Verify the funcation PointerEventTest_GetFixedDisplayXPosPen
1928 * @tc.type: FUNC
1929 * @tc.require:
1930 * @tc.author:
1931 */
1932 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedDisplayXPosPen, TestSize.Level2)
1933 {
1934 CALL_TEST_DEBUG;
1935 auto pointerEvent = PointerEvent::Create();
1936 ASSERT_NE(pointerEvent, nullptr);
1937 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1938 pointerEvent->SetPointerId(0);
1939 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1940 PointerEvent::PointerItem pointerItem1;
1941 int32_t disPlayX1 = 100;
1942 int32_t disPlayY1 = 110;
1943 pointerItem1.SetFixedDisplayXPos(disPlayX1);
1944 pointerItem1.SetFixedDisplayYPos(disPlayY1);
1945 pointerItem1.SetPointerId(0);
1946 pointerItem1.SetDownTime(0);
1947 pointerItem1.SetPressed(true);
1948 pointerItem1.SetPressure(30);
1949 pointerItem1.SetToolType(PointerEvent::TOOL_TYPE_PEN);
1950 pointerEvent->AddPointerItem(pointerItem1);
1951 PointerEvent::PointerItem pointerItemRes1;
1952 pointerEvent->GetPointerItem(0, pointerItemRes1);
1953 ASSERT_EQ(pointerItemRes1.GetFixedDisplayXPos(), disPlayX1);
1954 ASSERT_EQ(pointerItemRes1.GetFixedDisplayYPos(), disPlayY1);
1955 }
1956
1957 /**
1958 * @tc.name: PointerEventTest_GetFixedDisplayXPosJoystick
1959 * @tc.desc: Verify the funcation PointerEventTest_GetFixedDisplayXPosJoystick
1960 * @tc.type: FUNC
1961 * @tc.require:
1962 * @tc.author:
1963 */
1964 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedDisplayXPosJoystick, TestSize.Level2)
1965 {
1966 CALL_TEST_DEBUG;
1967 auto pointerEvent = PointerEvent::Create();
1968 ASSERT_NE(pointerEvent, nullptr);
1969 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK);
1970 pointerEvent->SetPointerId(0);
1971 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1972 PointerEvent::PointerItem pointerItem1;
1973 int32_t disPlayX1 = 100;
1974 int32_t disPlayY1 = 110;
1975 pointerItem1.SetFixedDisplayXPos(disPlayX1);
1976 pointerItem1.SetFixedDisplayYPos(disPlayY1);
1977 pointerItem1.SetPointerId(0);
1978 pointerItem1.SetDownTime(0);
1979 pointerItem1.SetPressed(true);
1980 pointerEvent->AddPointerItem(pointerItem1);
1981 PointerEvent::PointerItem pointerItemRes1;
1982 pointerEvent->GetPointerItem(0, pointerItemRes1);
1983 ASSERT_EQ(pointerItemRes1.GetFixedDisplayXPos(), disPlayX1);
1984 ASSERT_EQ(pointerItemRes1.GetFixedDisplayYPos(), disPlayY1);
1985 }
1986
1987 /**
1988 * @tc.name: PointerEventTest_GetFixedDisplayY
1989 * @tc.desc: Verify the funcation FixedDisplayY
1990 * @tc.type: FUNC
1991 * @tc.require:
1992 * @tc.author:
1993 */
1994 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedDisplayY, TestSize.Level2)
1995 {
1996 CALL_TEST_DEBUG;
1997 auto item = PointerEvent::PointerItem();
1998 int32_t disPlayY = 30;
1999 item.SetFixedDisplayY(disPlayY);
2000 ASSERT_EQ(item.GetFixedDisplayY(), disPlayY);
2001 }
2002
2003 /**
2004 * @tc.name: PointerEventTest_ClearAxisStatus_01
2005 * @tc.desc: Verify the funcation ClearAxisStatus
2006 * @tc.type: FUNC
2007 * @tc.require:
2008 * @tc.author:
2009 */
2010 HWTEST_F(PointerEventTest, PointerEventTest_ClearAxisStatus_01, TestSize.Level2)
2011 {
2012 CALL_TEST_DEBUG;
2013 auto pointer = PointerEvent::Create();
2014 PointerEvent::AxisType axisType = PointerEvent::AxisType::AXIS_TYPE_SCROLL_VERTICAL;
2015 ASSERT_NO_FATAL_FAILURE(pointer->SetAxisEventType(axisType));
2016 ASSERT_NO_FATAL_FAILURE(pointer->ClearAxisStatus(axisType));
2017 }
2018
2019 /**
2020 * @tc.name: PointerEventTest_SetVelocity
2021 * @tc.desc: Verify the funcation SetVelocity
2022 * @tc.type: FUNC
2023 * @tc.require:
2024 * @tc.author:
2025 */
2026 HWTEST_F(PointerEventTest, PointerEventTest_SetVelocity, TestSize.Level2)
2027 {
2028 CALL_TEST_DEBUG;
2029 auto pointer = PointerEvent::Create();
2030 double velocity = 8.0;
2031 ASSERT_NO_FATAL_FAILURE(pointer->SetVelocity(velocity));
2032 ASSERT_EQ(pointer->GetVelocity(), velocity);
2033 }
2034
2035 /**
2036 * @tc.name: PointerEventTest_SetHandOption
2037 * @tc.desc: Verify the funcation SetHandOption
2038 * @tc.type: FUNC
2039 * @tc.require:
2040 * @tc.author:
2041 */
2042 HWTEST_F(PointerEventTest, PointerEventTest_SetHandOption, TestSize.Level2)
2043 {
2044 CALL_TEST_DEBUG;
2045 auto pointer = PointerEvent::Create();
2046 int32_t handOption = 5;
2047 ASSERT_NO_FATAL_FAILURE(pointer->SetHandOption(handOption));
2048 ASSERT_EQ(pointer->GetHandOption(), handOption);
2049 }
2050
2051 /**
2052 * @tc.name: PointerEventTest_SetOriginPointerAction
2053 * @tc.desc: Verify the funcation SetOriginPointerAction
2054 * @tc.type: FUNC
2055 * @tc.require:
2056 * @tc.author:
2057 */
2058 HWTEST_F(PointerEventTest, PointerEventTest_SetOriginPointerAction, TestSize.Level2)
2059 {
2060 CALL_TEST_DEBUG;
2061 auto pointer = PointerEvent::Create();
2062 int32_t handOption = 5;
2063 ASSERT_NO_FATAL_FAILURE(pointer->SetOriginPointerAction(handOption));
2064 ASSERT_EQ(pointer->GetOriginPointerAction(), handOption);
2065 }
2066
2067 /**
2068 * @tc.name: PointerEventTest_SetPullId
2069 * @tc.desc: Verify the funcation SetPullId
2070 * @tc.type: FUNC
2071 * @tc.require:
2072 * @tc.author:
2073 */
2074 HWTEST_F(PointerEventTest, PointerEventTest_SetPullId, TestSize.Level2)
2075 {
2076 CALL_TEST_DEBUG;
2077 auto pointer = PointerEvent::Create();
2078 int32_t pullId = 5;
2079 ASSERT_NO_FATAL_FAILURE(pointer->SetPullId(pullId));
2080 ASSERT_EQ(pointer->GetPullId(), pullId);
2081 }
2082
2083 /**
2084 * @tc.name: PointerEventTest_SetScrollRows
2085 * @tc.desc: Verify the funcation SetScrollRows
2086 * @tc.type: FUNC
2087 * @tc.require:
2088 * @tc.author:
2089 */
2090 HWTEST_F(PointerEventTest, PointerEventTest_SetScrollRows, TestSize.Level2)
2091 {
2092 CALL_TEST_DEBUG;
2093 auto pointer = PointerEvent::Create();
2094 int32_t scrollRows = 5;
2095 ASSERT_NO_FATAL_FAILURE(pointer->SetScrollRows(scrollRows));
2096 ASSERT_EQ(pointer->GetScrollRows(), scrollRows);
2097 }
2098
2099 /**
2100 * @tc.name: PointerEventTest_SetFixedMode
2101 * @tc.desc: Verify the funcation SetFixedMode
2102 * @tc.type: FUNC
2103 * @tc.require:
2104 * @tc.author:
2105 */
2106 HWTEST_F(PointerEventTest, PointerEventTest_SetFixedMode, TestSize.Level2)
2107 {
2108 CALL_TEST_DEBUG;
2109 auto pointer = PointerEvent::Create();
2110 auto fixedMode = PointerEvent::FixedMode::SCREEN_MODE_MAX;
2111 ASSERT_NO_FATAL_FAILURE(pointer->SetFixedMode(fixedMode));
2112 ASSERT_EQ(pointer->GetFixedMode(), fixedMode);
2113 }
2114
2115 /**
2116 * @tc.name: PointerEventTest_GetFixedModeStr
2117 * @tc.desc: Verify the funcation GetFixedModeStr
2118 * @tc.type: FUNC
2119 * @tc.require:
2120 * @tc.author:
2121 */
2122 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedModeStr, TestSize.Level2)
2123 {
2124 CALL_TEST_DEBUG;
2125 auto pointer = PointerEvent::Create();
2126 auto fixedMode = PointerEvent::FixedMode::SCREEN_MODE_MAX;
2127 ASSERT_NO_FATAL_FAILURE(pointer->SetFixedMode(fixedMode));
2128 ASSERT_EQ(pointer->GetFixedModeStr(), "unknown");
2129 fixedMode = PointerEvent::FixedMode::NORMAL;
2130 pointer->SetFixedMode(fixedMode);
2131 ASSERT_EQ(pointer->GetFixedModeStr(), "normal");
2132 fixedMode = PointerEvent::FixedMode::AUTO;
2133 pointer->SetFixedMode(fixedMode);
2134 ASSERT_EQ(pointer->GetFixedModeStr(), "one-hand");
2135 }
2136
2137 /**
2138 * @tc.name: PointerEventTest_SetProcessedCallback
2139 * @tc.desc: Verify the funcation SetProcessedCallback
2140 * @tc.type: FUNC
2141 * @tc.require:
2142 * @tc.author:
2143 */
2144 HWTEST_F(PointerEventTest, PointerEventTest_SetProcessedCallback, TestSize.Level2)
2145 {
2146 CALL_TEST_DEBUG;
2147 auto inputEvent = InputEvent::Create();
2148 ASSERT_NO_FATAL_FAILURE(inputEvent->SetProcessedCallback(MyCallback));
2149 }
2150
2151 /**
2152 * @tc.name: PointerEventTest_DumpPointerAction_001
2153 * @tc.desc: Verify the funcation DumpPointerAction
2154 * @tc.type: FUNC
2155 * @tc.require:
2156 * @tc.author:
2157 */
2158 HWTEST_F(PointerEventTest, PointerEventTest_DumpPointerAction_001, TestSize.Level2)
2159 {
2160 CALL_TEST_DEBUG;
2161 auto pointerEvent = PointerEvent::Create();
2162 ASSERT_NE(pointerEvent, nullptr);
2163 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN);
2164 double axisValue = 0;
2165 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, axisValue);
2166 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2167
2168 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL, axisValue);
2169 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2170
2171 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, axisValue);
2172 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2173
2174 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_ROTATE, axisValue);
2175 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2176 }
2177
2178 /**
2179 * @tc.name: PointerEventTest_DumpPointerAction_002
2180 * @tc.desc: Verify the funcation DumpPointerAction
2181 * @tc.type: FUNC
2182 * @tc.require:
2183 * @tc.author:
2184 */
2185 HWTEST_F(PointerEventTest, PointerEventTest_DumpPointerAction_002, TestSize.Level2)
2186 {
2187 CALL_TEST_DEBUG;
2188 auto pointerEvent = PointerEvent::Create();
2189 ASSERT_NE(pointerEvent, nullptr);
2190 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
2191 double axisValue = 0;
2192 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, axisValue);
2193 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2194
2195 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL, axisValue);
2196 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2197
2198 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, axisValue);
2199 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2200
2201 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_ROTATE, axisValue);
2202 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2203 }
2204
2205 /**
2206 * @tc.name: PointerEventTest_DumpPointerAction_003
2207 * @tc.desc: Verify the funcation DumpPointerAction
2208 * @tc.type: FUNC
2209 * @tc.require:
2210 * @tc.author:
2211 */
2212 HWTEST_F(PointerEventTest, PointerEventTest_DumpPointerAction_003, TestSize.Level2)
2213 {
2214 CALL_TEST_DEBUG;
2215 auto pointerEvent = PointerEvent::Create();
2216 ASSERT_NE(pointerEvent, nullptr);
2217 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
2218 double axisValue = 0;
2219 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, axisValue);
2220 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2221
2222 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL, axisValue);
2223 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2224
2225 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, axisValue);
2226 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2227
2228 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_ROTATE, axisValue);
2229 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2230 }
2231
2232 /**
2233 * @tc.name: PointerEventTest_DumpPointerAction_004
2234 * @tc.desc: Verify the funcation DumpPointerAction
2235 * @tc.type: FUNC
2236 * @tc.require:
2237 * @tc.author:
2238 */
2239 HWTEST_F(PointerEventTest, PointerEventTest_DumpPointerAction_004, TestSize.Level2)
2240 {
2241 CALL_TEST_DEBUG;
2242 auto pointerEvent = PointerEvent::Create();
2243 ASSERT_NE(pointerEvent, nullptr);
2244 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
2245 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2246 }
2247
2248 /**
2249 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_001
2250 * @tc.desc: Verify if (pointers_.size() != 1)
2251 * @tc.type: FUNC
2252 * @tc.require:
2253 * @tc.author:
2254 */
2255 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_001, TestSize.Level2)
2256 {
2257 CALL_TEST_DEBUG;
2258 auto pointerEvent = PointerEvent::Create();
2259 ASSERT_NE(pointerEvent, nullptr);
2260 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2261 }
2262
2263 /**
2264 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_002
2265 * @tc.desc: Verify if (pointers_.size() != 1)
2266 * @tc.type: FUNC
2267 * @tc.require:
2268 * @tc.author:
2269 */
2270 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_002, TestSize.Level2)
2271 {
2272 CALL_TEST_DEBUG;
2273 auto pointerEvent = PointerEvent::Create();
2274 ASSERT_NE(pointerEvent, nullptr);
2275 PointerEvent::PointerItem item;
2276 pointerEvent->AddPointerItem(item);
2277 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2278 }
2279
2280 /**
2281 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_003
2282 * @tc.desc: Verify if (pressedButtons_.size() > maxPressedButtons)
2283 * @tc.type: FUNC
2284 * @tc.require:
2285 * @tc.author:
2286 */
2287 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_003, TestSize.Level2)
2288 {
2289 CALL_TEST_DEBUG;
2290 auto pointerEvent = PointerEvent::Create();
2291 ASSERT_NE(pointerEvent, nullptr);
2292 PointerEvent::PointerItem item;
2293 pointerEvent->AddPointerItem(item);
2294 pointerEvent->SetButtonPressed(0);
2295 pointerEvent->SetButtonPressed(1);
2296 pointerEvent->SetButtonPressed(2);
2297 pointerEvent->SetButtonPressed(3);
2298 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2299 }
2300
2301 /**
2302 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_004
2303 * @tc.desc: Verify if (pressedButtons_.size() > maxPressedButtons)
2304 * @tc.type: FUNC
2305 * @tc.require:
2306 * @tc.author:
2307 */
2308 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_004, TestSize.Level2)
2309 {
2310 CALL_TEST_DEBUG;
2311 auto pointerEvent = PointerEvent::Create();
2312 ASSERT_NE(pointerEvent, nullptr);
2313 PointerEvent::PointerItem item;
2314 pointerEvent->AddPointerItem(item);
2315 pointerEvent->SetButtonPressed(0);
2316 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2317 }
2318
2319 /**
2320 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_005
2321 * @tc.desc: Verify if (checkFlag)
2322 * @tc.type: FUNC
2323 * @tc.require:
2324 * @tc.author:
2325 */
2326 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_005, TestSize.Level2)
2327 {
2328 CALL_TEST_DEBUG;
2329 auto pointerEvent = PointerEvent::Create();
2330 ASSERT_NE(pointerEvent, nullptr);
2331 PointerEvent::PointerItem item;
2332 pointerEvent->AddPointerItem(item);
2333 pointerEvent->SetButtonPressed(0);
2334 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
2335 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2336 }
2337
2338 /**
2339 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_006
2340 * @tc.desc: Verify if (checkFlag)
2341 * @tc.type: FUNC
2342 * @tc.require:
2343 * @tc.author:
2344 */
2345 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_006, TestSize.Level2)
2346 {
2347 CALL_TEST_DEBUG;
2348 auto pointerEvent = PointerEvent::Create();
2349 ASSERT_NE(pointerEvent, nullptr);
2350 PointerEvent::PointerItem item;
2351 pointerEvent->AddPointerItem(item);
2352 pointerEvent->SetButtonPressed(0);
2353 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2354 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2355 }
2356
2357 /**
2358 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_007
2359 * @tc.desc: Verify if (buttonId != BUTTON_NONE)
2360 * @tc.type: FUNC
2361 * @tc.require:
2362 * @tc.author:
2363 */
2364 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_007, TestSize.Level2)
2365 {
2366 CALL_TEST_DEBUG;
2367 auto pointerEvent = PointerEvent::Create();
2368 ASSERT_NE(pointerEvent, nullptr);
2369 PointerEvent::PointerItem item;
2370 pointerEvent->AddPointerItem(item);
2371 pointerEvent->SetButtonPressed(-1);
2372 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2373 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2374 }
2375
2376 /**
2377 * @tc.name: PointerEventTest_SetTwist_001
2378 * @tc.desc: SetTwist
2379 * @tc.type: FUNC
2380 * @tc.require:
2381 * @tc.author:
2382 */
2383 HWTEST_F(PointerEventTest, PointerEventTest_SetTwist_001, TestSize.Level2)
2384 {
2385 CALL_TEST_DEBUG;
2386 auto pointerEvent = PointerEvent::Create();
2387 ASSERT_NE(pointerEvent, nullptr);
2388 PointerEvent::PointerItem item;
2389 int32_t twist = 3;
2390 ASSERT_NO_FATAL_FAILURE(item.SetTwist(twist));
2391 }
2392
2393 /**
2394 * @tc.name: PointerEventTest_GetTwist_001
2395 * @tc.desc: GetTwist
2396 * @tc.type: FUNC
2397 * @tc.require:
2398 * @tc.author:
2399 */
2400 HWTEST_F(PointerEventTest, PointerEventTest_GetTwist_001, TestSize.Level2)
2401 {
2402 CALL_TEST_DEBUG;
2403 auto pointerEvent = PointerEvent::Create();
2404 ASSERT_NE(pointerEvent, nullptr);
2405 PointerEvent::PointerItem item;
2406 int32_t twist = 3;
2407 ASSERT_NO_FATAL_FAILURE(item.SetTwist(twist));
2408 int32_t ret = item.GetTwist();
2409 ASSERT_EQ(ret, twist);
2410 }
2411
2412 /**
2413 * @tc.name: PointerEventTest_CheckInputEvent_001
2414 * @tc.desc: Verify point event
2415 * @tc.type: FUNC
2416 * @tc.require:
2417 */
2418 HWTEST_F(PointerEventTest, PointerEventTest_CheckInputEvent_001, TestSize.Level2)
2419 {
2420 CALL_TEST_DEBUG;
2421 auto inputEvent = InputEvent::Create();
2422 ASSERT_NE(inputEvent, nullptr);
2423 inputEvent->HasFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
2424 inputEvent->IsFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
2425 inputEvent->ClearFlag();
2426 }
2427
2428 /**
2429 * @tc.name: PointerEventTest_PointerItem_SetOrientation
2430 * @tc.desc: Test
2431 * @tc.type: FUNC
2432 * @tc.require:
2433 */
2434 HWTEST_F(PointerEventTest, PointerEventTest_PointerItem_SetOrientation, TestSize.Level2)
2435 {
2436 CALL_TEST_DEBUG;
2437 int32_t orientation = 1;
2438 PointerEvent::PointerItem item;
2439 ASSERT_NO_FATAL_FAILURE(item.SetOrientation(orientation));
2440 ASSERT_EQ(item.GetOrientation(), orientation);
2441 }
2442
2443 /**
2444 * @tc.name: PointerEventTest_PointerItem_GlobalCoordinates
2445 * @tc.desc: Test
2446 * @tc.type: FUNC
2447 * @tc.require:
2448 */
2449 HWTEST_F(PointerEventTest, PointerEventTest_PointerItem_GlobalCoordinates, TestSize.Level2)
2450 {
2451 CALL_TEST_DEBUG;
2452 double globalX { -1.0 };
2453 double globalY { -1.0 };
2454 PointerEvent::PointerItem item;
2455 ASSERT_NO_FATAL_FAILURE(item.SetGlobalX(globalX));
2456 ASSERT_NO_FATAL_FAILURE(item.SetGlobalY(globalY));
2457 ASSERT_EQ(static_cast<int32_t>(item.GetGlobalX()), static_cast<int32_t>(globalX));
2458 ASSERT_EQ(static_cast<int32_t>(item.GetGlobalY()), static_cast<int32_t>(globalY));
2459 }
2460
2461 /**
2462 * @tc.name: AddPointerItemTest1
2463 * @tc.desc: Test
2464 * @tc.type: FUNC
2465 * @tc.require:
2466 */
2467 HWTEST_F(PointerEventTest, AddPointerItemTest1, TestSize.Level2)
2468 {
2469 CALL_TEST_DEBUG;
2470 auto pointerEvent = PointerEvent::Create();
2471 ASSERT_NE(pointerEvent, nullptr);
2472 PointerEvent::PointerItem item1;
2473 item1.SetPointerId(0);
2474 pointerEvent->AddPointerItem(item1);
2475 PointerEvent::PointerItem item2;
2476 item2.SetPointerId(0);
2477 pointerEvent->AddPointerItem(item2);
2478 ASSERT_TRUE(!pointerEvent->IsValid());
2479 PointerEvent::PointerItem item3;
2480 item3.SetPointerId(0);
2481 pointerEvent->AddPointerItem(item3);
2482 PointerEvent::PointerItem item4;
2483 item4.SetPointerId(0);
2484 pointerEvent->AddPointerItem(item4);
2485 PointerEvent::PointerItem item5;
2486 item5.SetPointerId(0);
2487 pointerEvent->AddPointerItem(item5);
2488 PointerEvent::PointerItem item6;
2489 item6.SetPointerId(0);
2490 pointerEvent->AddPointerItem(item6);
2491 PointerEvent::PointerItem item7;
2492 item7.SetPointerId(0);
2493 pointerEvent->AddPointerItem(item7);
2494 PointerEvent::PointerItem item8;
2495 item8.SetPointerId(0);
2496 pointerEvent->AddPointerItem(item8);
2497 PointerEvent::PointerItem item9;
2498 item9.SetPointerId(0);
2499 pointerEvent->AddPointerItem(item9);
2500 PointerEvent::PointerItem item10;
2501 item10.SetPointerId(0);
2502 pointerEvent->AddPointerItem(item10);
2503 PointerEvent::PointerItem item11;
2504 item11.SetPointerId(0);
2505 ASSERT_NO_FATAL_FAILURE(pointerEvent->AddPointerItem(item11));
2506 }
2507
2508 /**
2509 * @tc.name: PointerEventTest_SetPressure_002
2510 * @tc.desc: Test the function SetPressure when tool type is pen and pressure < MAX_PRESSURE
2511 * @tc.type: FUNC
2512 * @tc.require:
2513 */
2514 HWTEST_F(PointerEventTest, PointerEventTest_SetPressure_002, TestSize.Level2)
2515 {
2516 CALL_TEST_DEBUG;
2517 PointerEvent::PointerItem item;
2518 item.SetToolType(PointerEvent::TOOL_TYPE_PEN);
2519 double pressure = 0.8;
2520 item.SetPressure(pressure);
2521 EXPECT_EQ(item.GetPressure(), 0.8);
2522 }
2523
2524 /**
2525 * @tc.name: PointerEventTest_SetPressure_003
2526 * @tc.desc: Test the function SetPressure when tool type is pen and pressure >= MAX_PRESSURE
2527 * @tc.type: FUNC
2528 * @tc.require:
2529 */
2530 HWTEST_F(PointerEventTest, PointerEventTest_SetPressure_003, TestSize.Level2)
2531 {
2532 CALL_TEST_DEBUG;
2533 PointerEvent::PointerItem item;
2534 item.SetToolType(PointerEvent::TOOL_TYPE_PEN);
2535 double pressure = 1.0 + 1.0;
2536 item.SetPressure(pressure);
2537 EXPECT_EQ(item.GetPressure(), 1.0);
2538 }
2539
2540 /**
2541 * @tc.name: PointerEventTest_SetPressure_004
2542 * @tc.desc: Test the function SetPressure when tool type is not pen and pressure > 1.0
2543 * @tc.type: FUNC
2544 * @tc.require:
2545 */
2546 HWTEST_F(PointerEventTest, PointerEventTest_SetPressure_004, TestSize.Level2)
2547 {
2548 CALL_TEST_DEBUG;
2549 PointerEvent::PointerItem item;
2550 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
2551 double pressure = 1.5;
2552 item.SetPressure(pressure);
2553 EXPECT_EQ(item.GetPressure(), 1.5);
2554 }
2555
2556 /**
2557 * @tc.name: PointerEventTest_ToString_001
2558 * @tc.desc: Verify ToString with single pointer and single pressed button
2559 * @tc.type: FUNC
2560 * @tc.require:
2561 */
2562 HWTEST_F(PointerEventTest, PointerEventTest_ToString_001, TestSize.Level2)
2563 {
2564 CALL_TEST_DEBUG;
2565 auto pointerEvent = PointerEvent::Create();
2566 ASSERT_NE(pointerEvent, nullptr);
2567 PointerEvent::PointerItem item;
2568 item.SetDisplayX(100);
2569 item.SetDisplayY(200);
2570 item.SetWindowX(10);
2571 item.SetWindowY(20);
2572 item.SetTargetWindowId(1);
2573 item.SetLongAxis(15);
2574 item.SetShortAxis(5);
2575 pointerEvent->pointers_.push_back(item);
2576 pointerEvent->pressedButtons_.insert(1);
2577 std::string str = pointerEvent->ToString();
2578 EXPECT_NE(str.find("displayX:100"), std::string::npos);
2579 EXPECT_NE(str.find("displayY:200"), std::string::npos);
2580 EXPECT_NE(str.find("windowX:10"), std::string::npos);
2581 EXPECT_NE(str.find("windowY:20"), std::string::npos);
2582 EXPECT_NE(str.find("pressedButtons:[1"), std::string::npos);
2583 }
2584
2585 /**
2586 * @tc.name: PointerEventTest_ToString_002
2587 * @tc.desc: Verify ToString with multiple pointers and multiple pressed buttons
2588 * @tc.type: FUNC
2589 * @tc.require:
2590 */
2591 HWTEST_F(PointerEventTest, PointerEventTest_ToString_002, TestSize.Level2)
2592 {
2593 CALL_TEST_DEBUG;
2594 auto pointerEvent = PointerEvent::Create();
2595 ASSERT_NE(pointerEvent, nullptr);
2596 PointerEvent::PointerItem item1;
2597 item1.SetDisplayX(300);
2598 item1.SetDisplayY(400);
2599 item1.SetWindowX(30);
2600 item1.SetWindowY(40);
2601 item1.SetTargetWindowId(2);
2602 item1.SetLongAxis(25);
2603 item1.SetShortAxis(15);
2604 PointerEvent::PointerItem item2;
2605 item2.SetDisplayX(500);
2606 item2.SetDisplayY(600);
2607 item2.SetWindowX(50);
2608 item2.SetWindowY(60);
2609 item2.SetTargetWindowId(3);
2610 item2.SetLongAxis(35);
2611 item2.SetShortAxis(25);
2612 pointerEvent->pointers_.push_back(item1);
2613 pointerEvent->pointers_.push_back(item2);
2614 pointerEvent->pressedButtons_.insert(1);
2615 pointerEvent->pressedButtons_.insert(2);
2616 pointerEvent->pressedButtons_.insert(3);
2617 std::string str = pointerEvent->ToString();
2618 EXPECT_NE(str.find("displayX:300"), std::string::npos);
2619 EXPECT_NE(str.find("displayY:400"), std::string::npos);
2620 EXPECT_NE(str.find("displayX:500"), std::string::npos);
2621 EXPECT_NE(str.find("pressedButtons:[1,2,3"), std::string::npos);
2622 }
2623
2624 /**
2625 * @tc.name: PointerEventTest_ToString_003
2626 * @tc.desc: Verify ToString with empty pointers and buttons
2627 * @tc.type: FUNC
2628 * @tc.require:
2629 */
2630 HWTEST_F(PointerEventTest, PointerEventTest_ToString_003, TestSize.Level2)
2631 {
2632 CALL_TEST_DEBUG;
2633 auto pointerEvent = PointerEvent::Create();
2634 ASSERT_NE(pointerEvent, nullptr);
2635 pointerEvent->pointers_.clear();
2636 pointerEvent->pressedButtons_.clear();
2637 std::string str = pointerEvent->ToString();
2638 EXPECT_NE(str.find("pointers:["), std::string::npos);
2639 EXPECT_NE(str.find("pressedButtons:["), std::string::npos);
2640 }
2641
2642 /**
2643 * @tc.name: PointerEventTest_AddPointerItem_001
2644 * @tc.desc: Verify AddPointerItem inserts a new pointer when list is empty
2645 * @tc.type: FUNC
2646 * @tc.require:
2647 */
2648 HWTEST_F(PointerEventTest, PointerEventTest_AddPointerItem_001, TestSize.Level2)
2649 {
2650 CALL_TEST_DEBUG;
2651 auto pointerEvent = PointerEvent::Create();
2652 ASSERT_NE(pointerEvent, nullptr);
2653 PointerEvent::PointerItem item;
2654 item.SetPointerId(1);
2655 item.SetDisplayX(100);
2656 item.SetDisplayY(200);
2657 ASSERT_NO_FATAL_FAILURE(pointerEvent->AddPointerItem(item));
2658 ASSERT_EQ(pointerEvent->pointers_.size(), 1U);
2659 auto firstItem = pointerEvent->pointers_.front();
2660 EXPECT_EQ(firstItem.GetPointerId(), 1);
2661 }
2662
2663 /**
2664 * @tc.name: PointerEventTest_AddPointerItem_002
2665 * @tc.desc: Verify AddPointerItem updates existing pointer when pointerId matches
2666 * @tc.type: FUNC
2667 * @tc.require:
2668 */
2669 HWTEST_F(PointerEventTest, PointerEventTest_AddPointerItem_002, TestSize.Level2)
2670 {
2671 CALL_TEST_DEBUG;
2672 auto pointerEvent = PointerEvent::Create();
2673 ASSERT_NE(pointerEvent, nullptr);
2674
2675 PointerEvent::PointerItem item1;
2676 item1.SetPointerId(2);
2677 item1.SetDisplayX(150);
2678 item1.SetDisplayY(250);
2679 pointerEvent->pointers_.push_back(item1);
2680 PointerEvent::PointerItem item2;
2681 item2.SetPointerId(2);
2682 item2.SetDisplayX(300);
2683 item2.SetDisplayY(400);
2684 ASSERT_NO_FATAL_FAILURE(pointerEvent->AddPointerItem(item2));
2685 ASSERT_EQ(pointerEvent->pointers_.size(), 1U);
2686 auto updatedItem = pointerEvent->pointers_.front();
2687 EXPECT_EQ(updatedItem.GetDisplayX(), 300);
2688 EXPECT_EQ(updatedItem.GetDisplayY(), 400);
2689 }
2690
2691 /**
2692 * @tc.name: PointerEventTest_AddPointerItem_003
2693 * @tc.desc: Verify AddPointerItem fails when exceeding MAX_N_POINTER_ITEMS
2694 * @tc.type: FUNC
2695 * @tc.require:
2696 */
2697 HWTEST_F(PointerEventTest, PointerEventTest_AddPointerItem_003, TestSize.Level2)
2698 {
2699 CALL_TEST_DEBUG;
2700 auto pointerEvent = PointerEvent::Create();
2701 ASSERT_NE(pointerEvent, nullptr);
2702 const int maxItems = 10;
2703 for (int i = 0; i < maxItems; i++) {
2704 PointerEvent::PointerItem item;
2705 item.SetPointerId(i);
2706 pointerEvent->pointers_.push_back(item);
2707 }
2708 PointerEvent::PointerItem newItem;
2709 newItem.SetPointerId(999);
2710 ASSERT_NO_FATAL_FAILURE(pointerEvent->AddPointerItem(newItem));
2711 EXPECT_EQ(pointerEvent->pointers_.size(), maxItems);
2712 }
2713
2714 /**
2715 * @tc.name: PointerEventTest_SetButtonPressed_001
2716 * @tc.desc: Test SetButtonPressed with a valid buttonId
2717 * @tc.type: FUNC
2718 * @tc.require:
2719 */
2720 HWTEST_F(PointerEventTest, PointerEventTest_SetButtonPressed_001, TestSize.Level1)
2721 {
2722 CALL_TEST_DEBUG;
2723 auto pointerEvent = PointerEvent::Create();
2724 ASSERT_NE(pointerEvent, nullptr);
2725 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetButtonPressed(1));
2726 EXPECT_EQ(pointerEvent->pressedButtons_.count(1), 1);
2727 }
2728
2729 /**
2730 * @tc.name: PointerEventTest_SetButtonPressed_002
2731 * @tc.desc: Test SetButtonPressed with duplicate buttonId
2732 * @tc.type: FUNC
2733 * @tc.require:
2734 */
2735 HWTEST_F(PointerEventTest, PointerEventTest_SetButtonPressed_002, TestSize.Level1)
2736 {
2737 CALL_TEST_DEBUG;
2738 auto pointerEvent = PointerEvent::Create();
2739 ASSERT_NE(pointerEvent, nullptr);
2740 pointerEvent->SetButtonPressed(2);
2741 EXPECT_EQ(pointerEvent->pressedButtons_.count(2), 1);
2742 pointerEvent->SetButtonPressed(2);
2743 EXPECT_EQ(pointerEvent->pressedButtons_.size(), 1);
2744 }
2745
2746 /**
2747 * @tc.name: PointerEventTest_SetButtonPressed_003
2748 * @tc.desc: Test SetButtonPressed when exceeding MAX_N_PRESSED_BUTTONS
2749 * @tc.type: FUNC
2750 * @tc.require:
2751 */
2752 HWTEST_F(PointerEventTest, PointerEventTest_SetButtonPressed_003, TestSize.Level1)
2753 {
2754 CALL_TEST_DEBUG;
2755 auto pointerEvent = PointerEvent::Create();
2756 ASSERT_NE(pointerEvent, nullptr);
2757 for (int i = 0; i < 10; i++) {
2758 pointerEvent->SetButtonPressed(i + 1);
2759 }
2760 EXPECT_EQ(pointerEvent->pressedButtons_.size(), 10);
2761 pointerEvent->SetButtonPressed(999);
2762 EXPECT_EQ(pointerEvent->pressedButtons_.size(), 10);
2763 }
2764
2765 /**
2766 * @tc.name: PointerEventTest_ReadFromParcel_002
2767 * @tc.desc: Verify ReadFromParcel fails when nPointers > MAX_N_POINTER_ITEMS
2768 * @tc.type: FUNC
2769 * @tc.require:
2770 */
2771 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel_002, TestSize.Level2)
2772 {
2773 CALL_TEST_DEBUG;
2774 Parcel parcel;
2775 parcel.WriteInt32(InputEvent::EVENT_TYPE_POINTER); // for InputEvent::ReadFromParcel
2776 parcel.WriteInt32(1); // pointerId_
2777 parcel.WriteInt32(10 + 1); // nPointers (exceed limit)
2778
2779 auto event = PointerEvent::Create();
2780 bool ret = event->ReadFromParcel(parcel);
2781 EXPECT_FALSE(ret);
2782 }
2783
2784 /**
2785 * @tc.name: PointerEventTest_ReadFromParcel_003
2786 * @tc.desc: Verify ReadFromParcel fails when PointerItem::ReadFromParcel returns false
2787 * @tc.type: FUNC
2788 * @tc.require:
2789 */
2790 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel_003, TestSize.Level2)
2791 {
2792 CALL_TEST_DEBUG;
2793 Parcel parcel;
2794 parcel.WriteInt32(InputEvent::EVENT_TYPE_POINTER); // InputEvent::ReadFromParcel
2795 parcel.WriteInt32(1); // pointerId_
2796 parcel.WriteInt32(1); // nPointers
2797 parcel.WriteInt32(-999); // illegal data to fail PointerItem::ReadFromParcel
2798
2799 auto event = PointerEvent::Create();
2800 bool ret = event->ReadFromParcel(parcel);
2801 EXPECT_FALSE(ret);
2802 }
2803
2804 /**
2805 * @tc.name: PointerEventTest_ReadFromParcel_004
2806 * @tc.desc: Verify ReadFromParcel fails when nPressedButtons > MAX_N_PRESSED_BUTTONS
2807 * @tc.type: FUNC
2808 * @tc.require:
2809 */
2810 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel_004, TestSize.Level2)
2811 {
2812 CALL_TEST_DEBUG;
2813 Parcel parcel;
2814 parcel.WriteInt32(InputEvent::EVENT_TYPE_POINTER); // InputEvent
2815 parcel.WriteInt32(1); // pointerId_
2816 parcel.WriteInt32(0); // nPointers
2817 parcel.WriteInt32(0); // bufferLength
2818 parcel.WriteInt32(10 + 1); // nPressedButtons
2819
2820 auto event = PointerEvent::Create();
2821 bool ret = event->ReadFromParcel(parcel);
2822 EXPECT_FALSE(ret);
2823 }
2824
2825 /**
2826 * @tc.name: PointerEventTest_ReadFromParcel_005
2827 * @tc.desc: Verify ReadFromParcel fails when nPressedKeys > MAX_N_PRESSED_KEYS
2828 * @tc.type: FUNC
2829 * @tc.require:
2830 */
2831 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel_005, TestSize.Level2)
2832 {
2833 CALL_TEST_DEBUG;
2834 Parcel parcel;
2835 parcel.WriteInt32(InputEvent::EVENT_TYPE_POINTER); // InputEvent
2836 parcel.WriteInt32(1); // pointerId_
2837 parcel.WriteInt32(0); // nPointers
2838 parcel.WriteInt32(0); // buffer
2839 parcel.WriteInt32(0); // nPressedButtons
2840 parcel.WriteInt32(10 + 1); // nPressedKeys
2841 auto event = PointerEvent::Create();
2842 bool ret = event->ReadFromParcel(parcel);
2843 EXPECT_FALSE(ret);
2844 }
2845
2846 /**
2847 * @tc.name: PointerEventTest_ReadAxisFromParcel_001
2848 * @tc.desc: Verify ReadAxisFromParcel when axes = 0 (no axis data)
2849 * @tc.type: FUNC
2850 * @tc.require:
2851 */
2852 HWTEST_F(PointerEventTest, PointerEventTest_ReadAxisFromParcel_001, TestSize.Level2)
2853 {
2854 CALL_TEST_DEBUG;
2855 Parcel parcel;
2856 parcel.WriteUint32(0);
2857 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
2858 bool ret = pointerEvent.ReadAxisFromParcel(parcel);
2859 EXPECT_TRUE(ret);
2860 }
2861
2862 /**
2863 * @tc.name: PointerEventTest_ReadAxisFromParcel_002
2864 * @tc.desc: Verify ReadAxisFromParcel with valid axis values
2865 * @tc.type: FUNC
2866 * @tc.require:
2867 */
2868 HWTEST_F(PointerEventTest, PointerEventTest_ReadAxisFromParcel_002, TestSize.Level2)
2869 {
2870 CALL_TEST_DEBUG;
2871 Parcel parcel;
2872 uint32_t axesMask = 0;
2873 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
2874 axesMask |= (1 << i);
2875 }
2876 parcel.WriteUint32(axesMask);
2877 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
2878 parcel.WriteDouble(static_cast<double>(i + 1) * 1.5);
2879 }
2880 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
2881 bool ret = pointerEvent.ReadAxisFromParcel(parcel);
2882 EXPECT_TRUE(ret);
2883 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
2884 double val = pointerEvent.GetAxisValue(static_cast<PointerEvent::AxisType>(i));
2885 EXPECT_DOUBLE_EQ(val, static_cast<double>(i + 1) * 1.5);
2886 }
2887 }
2888
2889 /**
2890 * @tc.name: PointerEventTest_ReadAxisFromParcel_003
2891 * @tc.desc: Verify ReadAxisFromParcel when only some axes are set
2892 * @tc.type: FUNC
2893 * @tc.require:
2894 */
2895 HWTEST_F(PointerEventTest, PointerEventTest_ReadAxisFromParcel_003, TestSize.Level2)
2896 {
2897 CALL_TEST_DEBUG;
2898 Parcel parcel;
2899 parcel.WriteUint32(0x02);
2900 parcel.WriteDouble(12.34);
2901 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
2902 bool ret = pointerEvent.ReadAxisFromParcel(parcel);
2903 EXPECT_TRUE(ret);
2904 EXPECT_DOUBLE_EQ(pointerEvent.GetAxisValue(static_cast<PointerEvent::AxisType>(1)), 12.34);
2905 }
2906
2907 /**
2908 * @tc.name: PointerEventTest_ReadEnhanceDataFromParcel_001
2909 * @tc.desc: Verify ReadEnhanceDataFromParcel with valid enhance data
2910 * @tc.type: FUNC
2911 * @tc.require:
2912 */
2913 HWTEST_F(PointerEventTest, PointerEventTest_ReadEnhanceDataFromParcel_001, TestSize.Level2)
2914 {
2915 CALL_TEST_DEBUG;
2916 Parcel parcel;
2917 int32_t size = 3;
2918 parcel.WriteInt32(size);
2919 parcel.WriteUint32(11);
2920 parcel.WriteUint32(22);
2921 parcel.WriteUint32(33);
2922 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
2923 bool ret = pointerEvent.ReadEnhanceDataFromParcel(parcel);
2924 EXPECT_TRUE(ret);
2925 const std::vector<uint8_t> &data = pointerEvent.GetEnhanceData();
2926 ASSERT_EQ(data.size(), static_cast<size_t>(size));
2927 EXPECT_EQ(data[0], static_cast<uint8_t>(11));
2928 EXPECT_EQ(data[1], static_cast<uint8_t>(22));
2929 EXPECT_EQ(data[2], static_cast<uint8_t>(33));
2930 }
2931
2932 /**
2933 * @tc.name: PointerEventTest_ReadEnhanceDataFromParcel_002
2934 * @tc.desc: Verify ReadEnhanceDataFromParcel with invalid size (exceed MAX_N_ENHANCE_DATA_SIZE)
2935 * @tc.type: FUNC
2936 * @tc.require:
2937 */
2938 HWTEST_F(PointerEventTest, PointerEventTest_ReadEnhanceDataFromParcel_002, TestSize.Level2)
2939 {
2940 CALL_TEST_DEBUG;
2941 Parcel parcel;
2942 parcel.WriteInt32(static_cast<int32_t>(64) + 1);
2943 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
2944 bool ret = pointerEvent.ReadEnhanceDataFromParcel(parcel);
2945 EXPECT_FALSE(ret);
2946 }
2947
2948 /**
2949 * @tc.name: PointerEventTest_ReadEnhanceDataFromParcel_003
2950 * @tc.desc: Verify ReadEnhanceDataFromParcel with negative size
2951 * @tc.type: FUNC
2952 * @tc.require:
2953 */
2954 HWTEST_F(PointerEventTest, PointerEventTest_ReadEnhanceDataFromParcel_003, TestSize.Level2)
2955 {
2956 CALL_TEST_DEBUG;
2957 Parcel parcel;
2958 parcel.WriteInt32(-1);
2959 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
2960 bool ret = pointerEvent.ReadEnhanceDataFromParcel(parcel);
2961 EXPECT_FALSE(ret);
2962 }
2963
2964 /**
2965 * @tc.name: PointerEventTest_ReadBufferFromParcel_001
2966 * @tc.desc: Verify ReadBufferFromParcel with valid buffer data
2967 * @tc.type: FUNC
2968 * @tc.require:
2969 */
2970 HWTEST_F(PointerEventTest, PointerEventTest_ReadBufferFromParcel_001, TestSize.Level2)
2971 {
2972 CALL_TEST_DEBUG;
2973 Parcel parcel;
2974 int32_t buffLen = 5;
2975 parcel.WriteInt32(buffLen);
2976 for (int32_t i = 0; i < buffLen; ++i) {
2977 parcel.WriteUint8(static_cast<uint8_t>(i + 10));
2978 }
2979 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
2980 bool ret = pointerEvent.ReadBufferFromParcel(parcel);
2981 EXPECT_TRUE(ret);
2982 const std::vector<uint8_t> &buffer = pointerEvent.GetBuffer();
2983 ASSERT_EQ(buffer.size(), static_cast<size_t>(buffLen));
2984 for (int32_t i = 0; i < buffLen; ++i) {
2985 EXPECT_EQ(buffer[i], static_cast<uint8_t>(i + 10));
2986 }
2987 }
2988
2989 /**
2990 * @tc.name: PointerEventTest_ReadBufferFromParcel_002
2991 * @tc.desc: Verify ReadBufferFromParcel when buffLen is 0 (no data)
2992 * @tc.type: FUNC
2993 * @tc.require:
2994 */
2995 HWTEST_F(PointerEventTest, PointerEventTest_ReadBufferFromParcel_002, TestSize.Level2)
2996 {
2997 CALL_TEST_DEBUG;
2998 Parcel parcel;
2999 parcel.WriteInt32(0);
3000 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
3001 bool ret = pointerEvent.ReadBufferFromParcel(parcel);
3002 EXPECT_TRUE(ret);
3003 EXPECT_TRUE(pointerEvent.GetBuffer().empty());
3004 }
3005
3006 /**
3007 * @tc.name: PointerEventTest_ReadBufferFromParcel_003
3008 * @tc.desc: Verify ReadBufferFromParcel with invalid buffer length (exceed MAX_N_BUFFER_SIZE)
3009 * @tc.type: FUNC
3010 * @tc.require:
3011 */
3012 HWTEST_F(PointerEventTest, PointerEventTest_ReadBufferFromParcel_003, TestSize.Level2)
3013 {
3014 CALL_TEST_DEBUG;
3015 Parcel parcel;
3016 parcel.WriteInt32(static_cast<int32_t>(64) + 1);
3017 PointerEvent pointerEvent(InputEvent::EVENT_TYPE_POINTER);
3018 bool ret = pointerEvent.ReadBufferFromParcel(parcel);
3019 EXPECT_FALSE(ret);
3020 }
3021
3022 /**
3023 * @tc.name: PointerEventTest_IsValidCheckTouch_001
3024 * @tc.desc: Return false when pointerId < 0
3025 * @tc.type: FUNC
3026 * @tc.require:
3027 */
3028 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckTouch_001, TestSize.Level2)
3029 {
3030 CALL_TEST_DEBUG;
3031 auto pointerEvent = PointerEvent::Create();
3032 ASSERT_NE(pointerEvent, nullptr);
3033 pointerEvent->SetPointerId(1);
3034 PointerEvent::PointerItem item;
3035 item.SetPointerId(-1);
3036 item.SetDownTime(100);
3037 item.SetPressed(false);
3038 pointerEvent->AddPointerItem(item);
3039 EXPECT_FALSE(pointerEvent->IsValidCheckTouch());
3040 }
3041
3042 /**
3043 * @tc.name: PointerEventTest_IsValidCheckTouch_002
3044 * @tc.desc: Return false when downTime <= 0
3045 * @tc.type: FUNC
3046 * @tc.require:
3047 */
3048 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckTouch_002, TestSize.Level2)
3049 {
3050 CALL_TEST_DEBUG;
3051 auto pointerEvent = PointerEvent::Create();
3052 ASSERT_NE(pointerEvent, nullptr);
3053 pointerEvent->SetPointerId(1);
3054 PointerEvent::PointerItem item;
3055 item.SetPointerId(1);
3056 item.SetDownTime(0);
3057 item.SetPressed(false);
3058 pointerEvent->AddPointerItem(item);
3059 EXPECT_FALSE(pointerEvent->IsValidCheckTouch());
3060 }
3061
3062 /**
3063 * @tc.name: PointerEventTest_IsValidCheckTouch_003
3064 * @tc.desc: Return false when IsPressed != false
3065 * @tc.type: FUNC
3066 * @tc.require:
3067 */
3068 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckTouch_003, TestSize.Level2)
3069 {
3070 CALL_TEST_DEBUG;
3071 auto pointerEvent = PointerEvent::Create();
3072 ASSERT_NE(pointerEvent, nullptr);
3073 pointerEvent->SetPointerId(1);
3074 PointerEvent::PointerItem item;
3075 item.SetPointerId(1);
3076 item.SetDownTime(100);
3077 item.SetPressed(true);
3078 pointerEvent->AddPointerItem(item);
3079 EXPECT_FALSE(pointerEvent->IsValidCheckTouch());
3080 }
3081
3082 /**
3083 * @tc.name: PointerEventTest_IsValidCheckTouch_004
3084 * @tc.desc: Return false when duplicate pointerId exists
3085 * @tc.type: FUNC
3086 * @tc.require:
3087 */
3088 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckTouch_004, TestSize.Level2)
3089 {
3090 CALL_TEST_DEBUG;
3091 auto pointerEvent = PointerEvent::Create();
3092 ASSERT_NE(pointerEvent, nullptr);
3093 pointerEvent->SetPointerId(1);
3094 PointerEvent::PointerItem item1;
3095 item1.SetPointerId(1);
3096 item1.SetDownTime(100);
3097 item1.SetPressed(false);
3098 PointerEvent::PointerItem item2;
3099 item2.SetPointerId(1);
3100 item2.SetDownTime(200);
3101 item2.SetPressed(false);
3102 pointerEvent->AddPointerItem(item1);
3103 pointerEvent->AddPointerItem(item2);
3104 EXPECT_FALSE(pointerEvent->IsValidCheckTouch());
3105 }
3106
3107 /**
3108 * @tc.name: PointerEventTest_IsValidCheckTouch_005
3109 * @tc.desc: Return false when no item matches touchPointID
3110 * @tc.type: FUNC
3111 * @tc.require:
3112 */
3113 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckTouch_005, TestSize.Level2)
3114 {
3115 CALL_TEST_DEBUG;
3116 auto pointerEvent = PointerEvent::Create();
3117 ASSERT_NE(pointerEvent, nullptr);
3118 pointerEvent->SetPointerId(10);
3119 PointerEvent::PointerItem item;
3120 item.SetPointerId(5);
3121 item.SetDownTime(100);
3122 item.SetPressed(false);
3123 pointerEvent->AddPointerItem(item);
3124 EXPECT_FALSE(pointerEvent->IsValidCheckTouch());
3125 }
3126 } // namespace MMI
3127 } // namespace OHOS
3128