1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "axis_event.h"
17 #include "define_multimodal.h"
18 #include "event_util_test.h"
19 #include "input_device.h"
20 #include "input_event.h"
21 #include "proto.h"
22 #include "util.h"
23
24 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "PointerEventTest"
26
27 namespace OHOS {
28 namespace MMI {
29 namespace {
30 using namespace testing::ext;
31 } // namespace
32 class PointerEventTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static std::shared_ptr<PointerEvent> CreatePointEvent();
36 };
37
SetUpTestCase(void)38 void PointerEventTest::SetUpTestCase(void)
39 {
40 ASSERT_TRUE(TestUtil->Init());
41 }
42
43 #ifdef OHOS_BUILD_ENABLE_POINTER
CreatePointEvent()44 std::shared_ptr<PointerEvent> PointerEventTest::CreatePointEvent()
45 {
46 auto pointerEvent = PointerEvent::Create();
47 CHKPP(pointerEvent);
48 int64_t downTime = GetMillisTime();
49 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
50 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
51 pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
52 pointerEvent->SetPointerId(1);
53 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
54 PointerEvent::PointerItem item;
55 item.SetPointerId(1);
56 item.SetDownTime(downTime);
57 item.SetPressed(true);
58
59 item.SetDisplayX(623);
60 item.SetDisplayY(823);
61 item.SetWindowX(600);
62 item.SetWindowY(800);
63
64 item.SetWidth(0);
65 item.SetHeight(0);
66 item.SetPressure(0);
67 item.SetDeviceId(0);
68 pointerEvent->AddPointerItem(item);
69 return pointerEvent;
70 }
71 #endif // OHOS_BUILD_ENABLE_POINTER
72
MyCallback(int32_t paramA,int64_t paramB)73 void MyCallback(int32_t paramA, int64_t paramB)
74 {
75 return;
76 }
77
78 /**
79 * @tc.name: PointerEventTest_CheckMousePointEvent_001
80 * @tc.desc: Verify mouse point event
81 * @tc.type: FUNC
82 * @tc.require:
83 */
84 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_001, TestSize.Level1)
85 {
86 CALL_TEST_DEBUG;
87 auto pointerEvent = PointerEvent::Create();
88 ASSERT_NE(pointerEvent, nullptr);
89 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
90 ASSERT_TRUE(!pointerEvent->IsValid());
91
92 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
93 pointerEvent->SetPointerId(-1);
94 ASSERT_TRUE(!pointerEvent->IsValid());
95
96 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
97 pointerEvent->SetPointerId(0);
98 PointerEvent::PointerItem item1;
99 item1.SetPointerId(0);
100 pointerEvent->AddPointerItem(item1);
101 PointerEvent::PointerItem item2;
102 item2.SetPointerId(0);
103 pointerEvent->AddPointerItem(item2);
104 ASSERT_TRUE(!pointerEvent->IsValid());
105 PointerEvent::PointerItem item3;
106 item3.SetPointerId(0);
107 pointerEvent->AddPointerItem(item3);
108 PointerEvent::PointerItem item4;
109 item4.SetPointerId(0);
110 pointerEvent->AddPointerItem(item4);
111 PointerEvent::PointerItem item5;
112 item5.SetPointerId(0);
113 pointerEvent->AddPointerItem(item5);
114 PointerEvent::PointerItem item6;
115 item6.SetPointerId(0);
116 pointerEvent->AddPointerItem(item6);
117
118 auto pointerEvent1 = PointerEvent::Create();
119 ASSERT_NE(pointerEvent1, nullptr);
120 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
121 pointerEvent1->SetPointerId(0);
122 pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
123 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
124 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_RIGHT);
125 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_MIDDLE);
126 item1.SetPointerId(0);
127 pointerEvent1->AddPointerItem(item1);
128 ASSERT_TRUE(!pointerEvent1->IsValid());
129 }
130
131 /**
132 * @tc.name: PointerEventTest_CheckMousePointEvent_002
133 * @tc.desc: Verify mouse point event
134 * @tc.type: FUNC
135 * @tc.require:
136 */
137 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_002, TestSize.Level1)
138 {
139 CALL_TEST_DEBUG;
140 auto pointerEvent1 = PointerEvent::Create();
141 ASSERT_NE(pointerEvent1, nullptr);
142 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
143 pointerEvent1->SetPointerId(0);
144 pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
145 PointerEvent::PointerItem item;
146 item.SetPointerId(0);
147 pointerEvent1->AddPointerItem(item);
148 ASSERT_TRUE(!pointerEvent1->IsValid());
149
150 auto pointerEvent2 = PointerEvent::Create();
151 ASSERT_NE(pointerEvent2, nullptr);
152 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
153 pointerEvent2->SetPointerId(0);
154 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
155 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
156 item.SetPointerId(0);
157 pointerEvent2->AddPointerItem(item);
158 ASSERT_TRUE(!pointerEvent2->IsValid());
159
160 auto pointerEvent3 = PointerEvent::Create();
161 ASSERT_NE(pointerEvent3, nullptr);
162 pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
163 pointerEvent3->SetPointerId(0);
164 pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
165 pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
166 pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
167 item.SetPointerId(0);
168 pointerEvent3->AddPointerItem(item);
169 ASSERT_TRUE(!pointerEvent3->IsValid());
170 }
171
172 /**
173 * @tc.name: PointerEventTest_CheckMousePointEvent_003
174 * @tc.desc: Verify mouse point event
175 * @tc.type: FUNC
176 * @tc.require:
177 */
178 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_003, TestSize.Level1)
179 {
180 CALL_TEST_DEBUG;
181 auto pointerEvent1 = PointerEvent::Create();
182 ASSERT_NE(pointerEvent1, nullptr);
183 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
184 pointerEvent1->SetPointerId(0);
185 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
186 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
187 pointerEvent1->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
188 PointerEvent::PointerItem item;
189 item.SetPointerId(0);
190 pointerEvent1->AddPointerItem(item);
191 ASSERT_TRUE(!pointerEvent1->IsValid());
192
193 auto pointerEvent2 = PointerEvent::Create();
194 ASSERT_NE(pointerEvent2, nullptr);
195 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
196 pointerEvent2->SetPointerId(0);
197 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
198 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
199 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
200 item.SetPointerId(-1);
201 pointerEvent2->AddPointerItem(item);
202 ASSERT_TRUE(!pointerEvent2->IsValid());
203 }
204
205 /**
206 * @tc.name: PointerEventTest_CheckMousePointEvent_004
207 * @tc.desc: Verify mouse point event
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_004, TestSize.Level1)
212 {
213 CALL_TEST_DEBUG;
214 auto pointerEvent1 = PointerEvent::Create();
215 ASSERT_NE(pointerEvent1, nullptr);
216 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
217 pointerEvent1->SetPointerId(0);
218 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
219 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
220 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
221 PointerEvent::PointerItem item;
222 item.SetPointerId(2);
223 pointerEvent1->AddPointerItem(item);
224 ASSERT_TRUE(!pointerEvent1->IsValid());
225
226 auto pointerEvent2 = PointerEvent::Create();
227 ASSERT_NE(pointerEvent2, nullptr);
228 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
229 pointerEvent2->SetPointerId(0);
230 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
231 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
232 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
233 item.SetPointerId(0);
234 item.SetDownTime(10010);
235 pointerEvent2->AddPointerItem(item);
236 ASSERT_TRUE(!pointerEvent2->IsValid());
237
238 auto pointerEvent3 = PointerEvent::Create();
239 ASSERT_NE(pointerEvent3, nullptr);
240 pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
241 pointerEvent3->SetPointerId(0);
242 pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
243 pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
244 pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
245 item.SetPointerId(0);
246 item.SetDownTime(0);
247 item.SetPressed(true);
248 pointerEvent3->AddPointerItem(item);
249 ASSERT_TRUE(!pointerEvent3->IsValid());
250 }
251
252 /**
253 * @tc.name: PointerEventTest_CheckMousePointEvent_005
254 * @tc.desc: Verify mouse point event
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_005, TestSize.Level1)
259 {
260 CALL_TEST_DEBUG;
261 auto pointerEvent = PointerEvent::Create();
262 ASSERT_NE(pointerEvent, nullptr);
263 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
264 pointerEvent->SetPointerId(0);
265 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
266 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
267 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
268 PointerEvent::PointerItem item;
269 item.SetPointerId(0);
270 item.SetDownTime(0);
271 item.SetPressed(false);
272 pointerEvent->AddPointerItem(item);
273 ASSERT_TRUE(pointerEvent->IsValid());
274 }
275
276 /**
277 * @tc.name: PointerEventTest_CheckMousePointEvent_006
278 * @tc.desc: Verify mouse point event
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_006, TestSize.Level1)
283 {
284 CALL_TEST_DEBUG;
285 auto inputEvent = InputEvent::Create();
286 ASSERT_NE(inputEvent, nullptr);
287 inputEvent->SetDeviceId(1);
288 inputEvent->SetTargetWindowId(1);
289 inputEvent->SetAgentWindowId(1);
290 auto event = PointerEvent::from(inputEvent);
291 ASSERT_EQ(event, nullptr);
292
293 auto pointerEvent = PointerEvent::Create();
294 ASSERT_NE(pointerEvent, nullptr);
295 pointerEvent->Reset();
296 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
297 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
298 pointerEvent->SetPointerId(0);
299 pointerEvent->SetDeviceId(inputEvent->GetDeviceId());
300 pointerEvent->SetTargetWindowId(inputEvent->GetTargetWindowId());
301 pointerEvent->SetAgentWindowId(inputEvent->GetAgentWindowId());
302 PointerEvent::PointerItem item1;
303 item1.SetPointerId(0);
304 item1.SetDownTime(0);
305 item1.SetPressed(true);
306 item1.SetWindowX(10);
307 item1.SetWindowY(10);
308 item1.SetDeviceId(inputEvent->GetDeviceId());
309 item1.SetRawDx(60);
310 item1.SetRawDy(60);
311 pointerEvent->AddPointerItem(item1);
312 PointerEvent::PointerItem item2;
313 item2.SetPointerId(1);
314 item2.SetDownTime(0);
315 item2.SetPressed(false);
316 item2.SetWindowX(item1.GetWindowX());
317 item2.SetWindowY(item1.GetWindowY());
318 item2.SetDeviceId(inputEvent->GetDeviceId());
319 item2.SetRawDx(100);
320 item2.SetRawDy(100);
321 pointerEvent->AddPointerItem(item2);
322 ASSERT_TRUE(pointerEvent != nullptr);
323 }
324
325 /**
326 * @tc.name: PointerEventTest_CheckTouchPointEvent_001
327 * @tc.desc: Verify touch screen event
328 * @tc.type: FUNC
329 * @tc.require:
330 */
331 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_001, TestSize.Level1)
332 {
333 CALL_TEST_DEBUG;
334 auto pointerEvent = PointerEvent::Create();
335 ASSERT_NE(pointerEvent, nullptr);
336 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
337 pointerEvent->SetPointerId(-1);
338 ASSERT_TRUE(!pointerEvent->IsValid());
339
340 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
341 pointerEvent->SetPointerId(0);
342 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
343 ASSERT_TRUE(!pointerEvent->IsValid());
344
345 auto pointerEvent1 = PointerEvent::Create();
346 ASSERT_NE(pointerEvent1, nullptr);
347 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
348 pointerEvent1->SetPointerId(0);
349 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
350 ASSERT_TRUE(!pointerEvent1->IsValid());
351
352 auto pointerEvent2 = PointerEvent::Create();
353 ASSERT_NE(pointerEvent2, nullptr);
354 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
355 pointerEvent2->SetPointerId(0);
356 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
357 pointerEvent2->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
358 ASSERT_TRUE(!pointerEvent2->IsValid());
359 }
360
361 /**
362 * @tc.name: PointerEventTest_CheckTouchPointEvent_002
363 * @tc.desc: Verify touch screen event
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_002, TestSize.Level1)
368 {
369 CALL_TEST_DEBUG;
370 auto pointerEvent1 = PointerEvent::Create();
371 ASSERT_NE(pointerEvent1, nullptr);
372 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
373 pointerEvent1->SetPointerId(0);
374 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
375 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
376 PointerEvent::PointerItem item;
377 item.SetPointerId(-1);
378 pointerEvent1->AddPointerItem(item);
379 ASSERT_TRUE(!pointerEvent1->IsValid());
380
381 auto pointerEvent2 = PointerEvent::Create();
382 ASSERT_NE(pointerEvent2, nullptr);
383 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
384 pointerEvent2->SetPointerId(0);
385 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
386 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
387 item.SetPointerId(0);
388 item.SetDownTime(0);
389 item.SetPressed(false);
390 pointerEvent2->AddPointerItem(item);
391 ASSERT_TRUE(!pointerEvent2->IsValid());
392 }
393
394 /**
395 * @tc.name: PointerEventTest_CheckTouchPointEvent_003
396 * @tc.desc: Verify touch screen event
397 * @tc.type: FUNC
398 * @tc.require:
399 */
400 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_003, TestSize.Level1)
401 {
402 CALL_TEST_DEBUG;
403 auto pointerEvent1 = PointerEvent::Create();
404 ASSERT_NE(pointerEvent1, nullptr);
405 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
406 pointerEvent1->SetPointerId(0);
407 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
408 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
409 PointerEvent::PointerItem item;
410 item.SetPointerId(0);
411 item.SetDownTime(100);
412 item.SetPressed(true);
413 pointerEvent1->AddPointerItem(item);
414 ASSERT_TRUE(!pointerEvent1->IsValid());
415
416 auto pointerEvent2 = PointerEvent::Create();
417 ASSERT_NE(pointerEvent2, nullptr);
418 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
419 pointerEvent2->SetPointerId(0);
420 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
421 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
422 PointerEvent::PointerItem item1;
423 item1.SetPointerId(0);
424 item1.SetDownTime(100);
425 item1.SetPressed(false);
426 pointerEvent2->AddPointerItem(item1);
427 PointerEvent::PointerItem item2;
428 item2.SetPointerId(0);
429 item2.SetDownTime(100);
430 item2.SetPressed(false);
431 pointerEvent2->AddPointerItem(item2);
432 ASSERT_FALSE(!pointerEvent2->IsValid());
433 }
434
435 /**
436 * @tc.name: PointerEventTest_CheckTouchPointEvent_004
437 * @tc.desc: Verify touch screen event
438 * @tc.type: FUNC
439 * @tc.require:
440 */
441 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_004, TestSize.Level1)
442 {
443 CALL_TEST_DEBUG;
444 auto pointerEvent = PointerEvent::Create();
445 ASSERT_NE(pointerEvent, nullptr);
446 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
447 pointerEvent->SetPointerId(0);
448 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
449 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
450 PointerEvent::PointerItem item1;
451 item1.SetPointerId(1);
452 item1.SetDownTime(100);
453 item1.SetPressed(false);
454 pointerEvent->AddPointerItem(item1);
455 PointerEvent::PointerItem item2;
456 item2.SetPointerId(2);
457 item2.SetDownTime(100);
458 item2.SetPressed(false);
459 pointerEvent->AddPointerItem(item2);
460 ASSERT_TRUE(!pointerEvent->IsValid());
461 }
462
463 /**
464 * @tc.name: PointerEventTest_CheckTouchPointEvent_005
465 * @tc.desc: Verify touch screen event
466 * @tc.type: FUNC
467 * @tc.require:
468 */
469 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_005, TestSize.Level1)
470 {
471 CALL_TEST_DEBUG;
472 auto pointerEvent = PointerEvent::Create();
473 ASSERT_NE(pointerEvent, nullptr);
474 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
475 pointerEvent->SetPointerId(0);
476 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
477 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
478 PointerEvent::PointerItem item1;
479 item1.SetPointerId(0);
480 item1.SetDownTime(100);
481 item1.SetPressed(false);
482 pointerEvent->AddPointerItem(item1);
483 PointerEvent::PointerItem item2;
484 item2.SetPointerId(1);
485 item2.SetDownTime(100);
486 item2.SetPressed(false);
487 pointerEvent->AddPointerItem(item2);
488 ASSERT_TRUE(pointerEvent->IsValid());
489 }
490
491 /**
492 * @tc.name: PointerEventTest_CheckTouchPointEvent_006
493 * @tc.desc: Verify touch screen event
494 * @tc.type: FUNC
495 * @tc.require: I5QSN3
496 */
497 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_006, TestSize.Level1)
498 {
499 CALL_TEST_DEBUG;
500 auto pointerEvent = PointerEvent::Create();
501 ASSERT_NE(pointerEvent, nullptr);
502 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
503 pointerEvent->SetPointerId(0);
504 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
505 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
506 PointerEvent::PointerItem item;
507 item.SetPointerId(0);
508 item.SetDownTime(100);
509 item.SetToolDisplayX(90);
510 item.SetToolDisplayY(90);
511 item.SetToolWindowX(50);
512 item.SetToolWindowY(50);
513 item.SetToolWidth(30);
514 item.SetToolHeight(30);
515 item.SetLongAxis(100);
516 item.SetShortAxis(20);
517 item.SetToolType(2);
518 item.SetTargetWindowId(0);
519 pointerEvent->AddPointerItem(item);
520 ASSERT_TRUE(pointerEvent->IsValid());
521 DumpWindowData(pointerEvent);
522 pointerEvent->RemovePointerItem(0);
523 pointerEvent->IsButtonPressed(0);
524 pointerEvent->ClearButtonPressed();
525 pointerEvent->ClearAxisValue();
526 pointerEvent->DeleteReleaseButton(PointerEvent::BUTTON_NONE);
527 ASSERT_FALSE(pointerEvent->IsValid());
528 }
529
530 /**
531 * @tc.name: PointerEventTest_CheckTouchInputEvent_001
532 * @tc.desc: Verify touch screen event
533 * @tc.type: FUNC
534 * @tc.require: I5QSN3
535 */
536 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchInputEvent_001, TestSize.Level1)
537 {
538 CALL_TEST_DEBUG;
539 auto inputEvent = InputEvent::Create();
540 ASSERT_NE(inputEvent, nullptr);
541 inputEvent->SetTargetDisplayId(0);
542 inputEvent->SetDeviceId(0);
543 inputEvent->EventTypeToString(InputEvent::EVENT_TYPE_POINTER);
544 inputEvent->HasFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
545 inputEvent->ClearFlag();
546 }
547
548 /**
549 * @tc.name: PointerEventTest_SetEnhanceData_001
550 * @tc.desc: Set the enhance data.
551 * @tc.type: FUNC
552 * @tc.require:
553 */
554 HWTEST_F(PointerEventTest, PointerEventTest_SetEnhanceData_001, TestSize.Level1)
555 {
556 CALL_TEST_DEBUG;
557 auto pointerEvent = PointerEvent::Create();
558 ASSERT_NE(pointerEvent, nullptr);
559 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
560 pointerEvent->SetPointerId(0);
561 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
562 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
563 PointerEvent::PointerItem item;
564 item.SetPointerId(-1);
565 pointerEvent->AddPointerItem(item);
566 uint32_t enHanceDataLen = 3;
567 uint8_t enhanceDataBuf[enHanceDataLen];
568 std::vector<uint8_t> enhanceData;
569 for (uint32_t i = 0; i < enHanceDataLen; i++) {
570 enhanceData.push_back(enhanceDataBuf[i]);
571 }
572 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
573 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetEnhanceData(enhanceData));
574 ASSERT_EQ(pointerEvent->GetEnhanceData(), enhanceData);
575 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
576 }
577
578 /**
579 * @tc.name: PointerEventTest_SetToolDisplayX_001
580 * @tc.desc: Set Tool Display Coordinates.
581 * @tc.type: FUNC
582 * @tc.require:
583 */
584 HWTEST_F(PointerEventTest, PointerEventTest_SetToolDisplayX_001, TestSize.Level1)
585 {
586 CALL_TEST_DEBUG;
587 auto pointerEvent = PointerEvent::Create();
588 ASSERT_NE(pointerEvent, nullptr);
589 int32_t displayX = 90;
590 PointerEvent::PointerItem item;
591 item.SetPointerId(1);
592 item.SetDownTime(0);
593 ASSERT_NO_FATAL_FAILURE(item.SetToolDisplayX(displayX));
594 ASSERT_EQ(item.GetToolDisplayX(), displayX);
595 pointerEvent->AddPointerItem(item);
596 }
597
598 /**
599 * @tc.name: PointerEventTest_SetToolDisplayY_001
600 * @tc.desc: Set Tool Display Coordinates.
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(PointerEventTest, PointerEventTest_SetToolDisplayY_001, TestSize.Level1)
605 {
606 CALL_TEST_DEBUG;
607 auto pointerEvent = PointerEvent::Create();
608 ASSERT_NE(pointerEvent, nullptr);
609 int32_t displayY = 70;
610 PointerEvent::PointerItem item;
611 item.SetPointerId(2);
612 item.SetDownTime(1);
613 ASSERT_NO_FATAL_FAILURE(item.SetToolDisplayY(displayY));
614 ASSERT_EQ(item.GetToolDisplayY(), displayY);
615 pointerEvent->AddPointerItem(item);
616 }
617
618 /**
619 * @tc.name: PointerEventTest_SetToolWidth_001
620 * @tc.desc: Set Tool Display Width.
621 * @tc.type: FUNC
622 * @tc.require:
623 */
624 HWTEST_F(PointerEventTest, PointerEventTest_SetToolWidth_001, TestSize.Level1)
625 {
626 CALL_TEST_DEBUG;
627 int32_t toolWidth = 30;
628 PointerEvent::PointerItem item;
629 item.SetPointerId(3);
630 item.SetDownTime(0);
631 ASSERT_NO_FATAL_FAILURE(item.SetToolWidth(toolWidth));
632 ASSERT_EQ(item.GetToolWidth(), toolWidth);
633 }
634
635 /**
636 * @tc.name: PointerEventTest_SetToolHeight_001
637 * @tc.desc: Set Tool Display Height.
638 * @tc.type: FUNC
639 * @tc.require:
640 */
641 HWTEST_F(PointerEventTest, PointerEventTest_SetToolHeight_001, TestSize.Level1)
642 {
643 CALL_TEST_DEBUG;
644 int32_t toolHeight = 40;
645 PointerEvent::PointerItem item;
646 item.SetPointerId(4);
647 item.SetDownTime(1);
648 ASSERT_NO_FATAL_FAILURE(item.SetToolHeight(toolHeight));
649 ASSERT_EQ(item.GetToolHeight(), toolHeight);
650 }
651
652 /**
653 * @tc.name: PointerEventTest_SetLongAxis_001
654 * @tc.desc: Sets the long axis of the touch point area.
655 * @tc.type: FUNC
656 * @tc.require:
657 */
658 HWTEST_F(PointerEventTest, PointerEventTest_SetLongAxis_001, TestSize.Level1)
659 {
660 CALL_TEST_DEBUG;
661 int32_t longAxis = 50;
662 PointerEvent::PointerItem item;
663 item.SetPointerId(5);
664 item.SetDownTime(0);
665 ASSERT_NO_FATAL_FAILURE(item.SetLongAxis(longAxis));
666 ASSERT_EQ(item.GetLongAxis(), longAxis);
667 }
668
669 /**
670 * @tc.name: PointerEventTest_SetShortAxis_001
671 * @tc.desc: Sets the short axis of the touch point area.
672 * @tc.type: FUNC
673 * @tc.require:
674 */
675 HWTEST_F(PointerEventTest, PointerEventTest_SetShortAxis_001, TestSize.Level1)
676 {
677 CALL_TEST_DEBUG;
678 int32_t shortAxis = 45;
679 PointerEvent::PointerItem item;
680 item.SetPointerId(6);
681 item.SetDownTime(1);
682 ASSERT_NO_FATAL_FAILURE(item.SetShortAxis(shortAxis));
683 ASSERT_EQ(item.GetShortAxis(), shortAxis);
684 }
685
686 /**
687 * @tc.name: PointerEventTest_GetPointerCount_001
688 * @tc.desc: Get pointer count
689 * @tc.type: FUNC
690 * @tc.require:
691 */
692 HWTEST_F(PointerEventTest, PointerEventTest_GetPointerCount_001, TestSize.Level1)
693 {
694 CALL_TEST_DEBUG;
695 auto pointerEvent = PointerEvent::Create();
696 int32_t pointerCount = pointerEvent->GetPointerCount();
697 ASSERT_EQ(pointerCount, 0);
698 }
699
700 /**
701 * @tc.name: PointerEventTest_SetExtraData_001
702 * @tc.desc: Set extra data
703 * @tc.type: FUNC
704 * @tc.require:
705 */
706 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_001, TestSize.Level1)
707 {
708 CALL_TEST_DEBUG;
709 const uint32_t length = 5;
710 std::shared_ptr<const uint8_t[]> data;
711 auto inputEvent = InputEvent::Create();
712 ASSERT_NE(inputEvent, nullptr);
713 inputEvent->SetExtraData(data, length);
714 }
715
716 /**
717 * @tc.name: PointerEventTest_GetExtraData_001
718 * @tc.desc: Get extra data
719 * @tc.type: FUNC
720 * @tc.require:
721 */
722 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_001, TestSize.Level1)
723 {
724 CALL_TEST_DEBUG;
725 auto inputEvent = InputEvent::Create();
726 std::shared_ptr<const uint8_t[]> retrievedData;
727 uint32_t retrievedLength;
728 inputEvent->GetExtraData(retrievedData, retrievedLength);
729 }
730
731 /**
732 * @tc.name: PointerEventTest_SetRawDx_001
733 * @tc.desc: Sets the raw X coordinate.
734 * @tc.type: FUNC
735 * @tc.require:
736 */
737 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDx_001, TestSize.Level1)
738 {
739 CALL_TEST_DEBUG;
740 int32_t rawDx = 55;
741 PointerEvent::PointerItem item;
742 item.SetPointerId(7);
743 item.SetDownTime(0);
744 ASSERT_NO_FATAL_FAILURE(item.SetRawDx(rawDx));
745 ASSERT_EQ(item.GetRawDx(), rawDx);
746 }
747
748 /**
749 * @tc.name: PointerEventTest_SetRawDy_001
750 * @tc.desc: Sets the raw Y coordinate.
751 * @tc.type: FUNC
752 * @tc.require:
753 */
754 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDy_001, TestSize.Level1)
755 {
756 CALL_TEST_DEBUG;
757 int32_t rawDy = 60;
758 PointerEvent::PointerItem item;
759 item.SetPointerId(8);
760 item.SetDownTime(1);
761 ASSERT_NO_FATAL_FAILURE(item.SetRawDy(rawDy));
762 ASSERT_EQ(item.GetRawDy(), rawDy);
763 }
764
765 /**
766 * @tc.name: PointerEventTest_ClearFlag_001
767 * @tc.desc: Clears all flags of an input event.
768 * @tc.type: FUNC
769 * @tc.require:
770 */
771 HWTEST_F(PointerEventTest, PointerEventTest_ClearFlag_001, TestSize.Level1)
772 {
773 CALL_TEST_DEBUG;
774 auto inputEvent = InputEvent::Create();
775 ASSERT_NE(inputEvent, nullptr);
776 inputEvent->SetTargetDisplayId(0);
777 inputEvent->SetDeviceId(0);
778 inputEvent->EventTypeToString(InputEvent::EVENT_TYPE_POINTER);
779 inputEvent->AddFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
780 ASSERT_NO_FATAL_FAILURE(inputEvent->ClearFlag());
781 ASSERT_EQ(inputEvent->GetFlag(), InputEvent::EVENT_FLAG_NONE);
782 }
783
784 /**
785 * @tc.name: PointerEventTest_From_001
786 * @tc.desc: Convert InputEvent to nullptr.
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(PointerEventTest, PointerEventTest_From_001, TestSize.Level1)
791 {
792 CALL_TEST_DEBUG;
793 auto inputEvent = InputEvent::Create();
794 ASSERT_NE(inputEvent, nullptr);
795 inputEvent->SetDeviceId(2);
796 inputEvent->SetTargetWindowId(2);
797 inputEvent->SetAgentWindowId(2);
798 auto event = PointerEvent::from(inputEvent);
799 ASSERT_EQ(event, nullptr);
800 }
801
802 /**
803 * @tc.name: PointerEventTest_Reset_001
804 * @tc.desc: Reset pointer event.
805 * @tc.type: FUNC
806 * @tc.require:
807 */
808 HWTEST_F(PointerEventTest, PointerEventTest_Reset_001, TestSize.Level1)
809 {
810 CALL_TEST_DEBUG;
811 auto pointerEvent = PointerEvent::Create();
812 ASSERT_NE(pointerEvent, nullptr);
813 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
814 pointerEvent->SetPointerId(1);
815 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
816 ASSERT_NO_FATAL_FAILURE(pointerEvent->Reset());
817 ASSERT_EQ(pointerEvent->GetSourceType(), PointerEvent::SOURCE_TYPE_UNKNOWN);
818 ASSERT_EQ(pointerEvent->GetPointerId(), -1);
819 ASSERT_EQ(pointerEvent->GetPointerAction(), PointerEvent::POINTER_ACTION_UNKNOWN);
820 }
821
822 /**
823 * @tc.name: PointerEventTest_IsButtonPressed_001
824 * @tc.desc: Determine whether the button is pressed.
825 * @tc.type: FUNC
826 * @tc.require:
827 */
828 HWTEST_F(PointerEventTest, PointerEventTest_IsButtonPressed_001, TestSize.Level1)
829 {
830 CALL_TEST_DEBUG;
831 auto pointerEvent = PointerEvent::Create();
832 ASSERT_NE(pointerEvent, nullptr);
833 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
834 pointerEvent->SetPointerId(0);
835 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
836 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
837 pointerEvent->SetButtonPressed(0);
838 ASSERT_TRUE(pointerEvent->IsButtonPressed(0));
839 }
840
841 /**
842 * @tc.name: PointerEventTest_DeleteReleaseButton_001
843 * @tc.desc: Deletes a released button.
844 * @tc.type: FUNC
845 * @tc.require:
846 */
847 HWTEST_F(PointerEventTest, PointerEventTest_DeleteReleaseButton_001, TestSize.Level1)
848 {
849 CALL_TEST_DEBUG;
850 auto pointerEvent = PointerEvent::Create();
851 ASSERT_NE(pointerEvent, nullptr);
852 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
853 pointerEvent->SetPointerId(0);
854 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
855 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
856 pointerEvent->SetButtonPressed(0);
857 ASSERT_NO_FATAL_FAILURE(pointerEvent->DeleteReleaseButton(0));
858 std::set<int32_t> pressButtons = pointerEvent->GetPressedButtons();
859 ASSERT_EQ(pressButtons.size(), 0);
860 }
861
862 /**
863 * @tc.name: PointerEventTest_ClearButtonPressed_001
864 * @tc.desc: Clears the button in the pressed state.
865 * @tc.type: FUNC
866 * @tc.require:
867 */
868 HWTEST_F(PointerEventTest, PointerEventTest_ClearButtonPressed_001, TestSize.Level1)
869 {
870 CALL_TEST_DEBUG;
871 auto pointerEvent = PointerEvent::Create();
872 ASSERT_NE(pointerEvent, nullptr);
873 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
874 pointerEvent->SetPointerId(0);
875 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
876 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
877 pointerEvent->SetButtonPressed(0);
878 ASSERT_NO_FATAL_FAILURE(pointerEvent->ClearButtonPressed());
879 std::set<int32_t> pressButtons = pointerEvent->GetPressedButtons();
880 ASSERT_EQ(pressButtons.size(), 0);
881 }
882
883 /**
884 * @tc.name: PointerEventTest_ClearAxisValue_001
885 * @tc.desc: Clears the button in the pressed state.
886 * @tc.type: FUNC
887 * @tc.require:
888 */
889 HWTEST_F(PointerEventTest, PointerEventTest_ClearAxisValue_001, TestSize.Level1)
890 {
891 CALL_TEST_DEBUG;
892 auto pointerEvent = PointerEvent::Create();
893 ASSERT_NE(pointerEvent, nullptr);
894 pointerEvent->SetPointerId(0);
895 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, 30.0);
896 double axisValue = pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL);
897 ASSERT_EQ(axisValue, 30.0);
898 ASSERT_NO_FATAL_FAILURE(pointerEvent->ClearAxisValue());
899 ASSERT_EQ(pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL), 0);
900 }
901
902 /**
903 * @tc.name: PointerEventTest_SetZorderValue_001
904 * @tc.desc: Sets the zOrder for this event, inject to windows whose zOrder less than the target zOrder.
905 * @tc.type: FUNC
906 * @tc.require:
907 */
908 HWTEST_F(PointerEventTest, PointerEventTest_SetZorderValue_001, TestSize.Level1)
909 {
910 CALL_TEST_DEBUG;
911 auto pointerEvent = PointerEvent::Create();
912 ASSERT_NE(pointerEvent, nullptr);
913 pointerEvent->SetPointerId(0);
914 pointerEvent->SetZOrder(30.0);
915 float zOrder = pointerEvent->GetZOrder();
916 ASSERT_EQ(zOrder, 30.0);
917 }
918
919 /**
920 * @tc.name: PointerEventTest_IsValid_001
921 * @tc.desc: Checks whether this input event is valid.
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(PointerEventTest, PointerEventTest_IsValid_001, TestSize.Level1)
926 {
927 CALL_TEST_DEBUG;
928 auto pointerEvent = PointerEvent::Create();
929 ASSERT_NE(pointerEvent, nullptr);
930 pointerEvent->SetPointerId(0);
931 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
932 ASSERT_FALSE(pointerEvent->IsValid());
933 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
934 ASSERT_FALSE(pointerEvent->IsValid());
935 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
936 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
937 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
938 PointerEvent::PointerItem item;
939 item.SetPointerId(0);
940 item.SetDownTime(0);
941 item.SetPressed(false);
942 pointerEvent->AddPointerItem(item);
943 ASSERT_TRUE(pointerEvent->IsValid());
944 }
945
946 /**
947 * @tc.name: PointerEventTest_GetFingerCount_001
948 * @tc.desc: Sets the fingerCount for this event.
949 * @tc.type: FUNC
950 * @tc.require:
951 */
952 HWTEST_F(PointerEventTest, PointerEventTest_GetFingerCount_001, TestSize.Level1)
953 {
954 CALL_TEST_DEBUG;
955 auto pointerEvent = PointerEvent::Create();
956 ASSERT_NE(pointerEvent, nullptr);
957 pointerEvent->SetFingerCount(-12);
958 int32_t fingerCount = pointerEvent->GetFingerCount();
959 ASSERT_EQ(fingerCount, -12);
960 pointerEvent->SetFingerCount(-6);
961 fingerCount = pointerEvent->GetFingerCount();
962 ASSERT_EQ(fingerCount, -6);
963 pointerEvent->SetFingerCount(0);
964 fingerCount = pointerEvent->GetFingerCount();
965 ASSERT_EQ(fingerCount, 0);
966 pointerEvent->SetFingerCount(6);
967 fingerCount = pointerEvent->GetFingerCount();
968 ASSERT_EQ(fingerCount, 6);
969 pointerEvent->SetFingerCount(12);
970 fingerCount = pointerEvent->GetFingerCount();
971 ASSERT_EQ(fingerCount, 12);
972 }
973
974 /**
975 * @tc.name: PointerEventTest_ClearBuffer_001
976 * @tc.desc: Clear the buffer data.
977 * @tc.type: FUNC
978 * @tc.require:
979 */
980 HWTEST_F(PointerEventTest, PointerEventTest_ClearBuffer_001, TestSize.Level1)
981 {
982 CALL_TEST_DEBUG;
983 auto pointerEvent = PointerEvent::Create();
984 ASSERT_NE(pointerEvent, nullptr);
985 uint32_t enHanceDataLen = 3;
986 uint8_t enhanceDataBuf[enHanceDataLen];
987 std::vector<uint8_t> enhanceData;
988 for (uint32_t i = 0; i < enHanceDataLen; i++) {
989 enhanceData.push_back(enhanceDataBuf[i]);
990 }
991 pointerEvent->SetBuffer(enhanceData);
992 std::vector<uint8_t> buffer = pointerEvent->GetBuffer();
993 ASSERT_NE(buffer.size(), 0);
994 pointerEvent->ClearBuffer();
995 buffer = pointerEvent->GetBuffer();
996 ASSERT_EQ(buffer.size(), 0);
997 }
998
999 /**
1000 * @tc.name: PointerEventTest_SetOriginPointerId_001
1001 * @tc.desc: Sets the origin id of the pointer in this event.
1002 * @tc.type: FUNC
1003 * @tc.require:
1004 */
1005 HWTEST_F(PointerEventTest, PointerEventTest_SetOriginPointerId_001, TestSize.Level1)
1006 {
1007 CALL_TEST_DEBUG;
1008 int32_t originPointerId = 11;
1009 PointerEvent::PointerItem item;
1010 ASSERT_NO_FATAL_FAILURE(item.SetOriginPointerId(originPointerId));
1011 ASSERT_EQ(item.GetOriginPointerId(), originPointerId);
1012 }
1013
1014 /**
1015 * @tc.name: PointerEventTest_SetDisplayXPos_001
1016 * @tc.desc: Sets the x coordinate relative to the upper left corner of the screen.
1017 * @tc.type: FUNC
1018 * @tc.require:
1019 */
1020 HWTEST_F(PointerEventTest, PointerEventTest_SetDisplayXPos_001, TestSize.Level1)
1021 {
1022 CALL_TEST_DEBUG;
1023 double displayX = 10.0;
1024 PointerEvent::PointerItem item;
1025 ASSERT_NO_FATAL_FAILURE(item.SetDisplayXPos(displayX));
1026 ASSERT_EQ(item.GetDisplayXPos(), displayX);
1027 }
1028
1029 /**
1030 * @tc.name: PointerEventTest_SetDisplayYPos_001
1031 * @tc.desc: Sets the y coordinate relative to the upper left corner of the screen.
1032 * @tc.type: FUNC
1033 * @tc.require:
1034 */
1035 HWTEST_F(PointerEventTest, PointerEventTest_SetDisplayYPos_001, TestSize.Level1)
1036 {
1037 CALL_TEST_DEBUG;
1038 double displayY = 10.0;
1039 PointerEvent::PointerItem item;
1040 ASSERT_NO_FATAL_FAILURE(item.SetDisplayYPos(displayY));
1041 ASSERT_EQ(item.GetDisplayYPos(), displayY);
1042 }
1043
1044 /**
1045 * @tc.name: PointerEventTest_SetWindowXPos_001
1046 * @tc.desc: Sets the x coordinate of the active window.
1047 * @tc.type: FUNC
1048 * @tc.require:
1049 */
1050 HWTEST_F(PointerEventTest, PointerEventTest_SetWindowXPos_001, TestSize.Level1)
1051 {
1052 CALL_TEST_DEBUG;
1053 double x = 10.0;
1054 PointerEvent::PointerItem item;
1055 ASSERT_NO_FATAL_FAILURE(item.SetWindowXPos(x));
1056 ASSERT_EQ(item.GetWindowXPos(), x);
1057 }
1058
1059 /**
1060 * @tc.name: PointerEventTest_SetWindowYPos_001
1061 * @tc.desc: Sets the y coordinate of the active window.
1062 * @tc.type: FUNC
1063 * @tc.require:
1064 */
1065 HWTEST_F(PointerEventTest, PointerEventTest_SetWindowYPos_001, TestSize.Level1)
1066 {
1067 CALL_TEST_DEBUG;
1068 double y = 10.0;
1069 PointerEvent::PointerItem item;
1070 ASSERT_NO_FATAL_FAILURE(item.SetWindowYPos(y));
1071 ASSERT_EQ(item.GetWindowYPos(), y);
1072 }
1073
1074 /**
1075 * @tc.name: PointerEventTest_ActionToShortStr_001
1076 * @tc.desc: Verify ActionToShortStr
1077 * @tc.type: FUNC
1078 * @tc.require:
1079 * @tc.author:
1080 */
1081 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_001, TestSize.Level1)
1082 {
1083 CALL_TEST_DEBUG;
1084 int32_t eventType = 1;
1085 AxisEvent axisevent(eventType);
1086 int32_t action = AxisEvent::AXIS_ACTION_CANCEL;
1087 auto ret = axisevent.ActionToShortStr(action);
1088 ASSERT_EQ(ret, "A:C:");
1089 action = AxisEvent::AXIS_ACTION_START;
1090 ret = axisevent.ActionToShortStr(action);
1091 ASSERT_EQ(ret, "A:S:");
1092 action = AxisEvent::AXIS_ACTION_UPDATE;
1093 ret = axisevent.ActionToShortStr(action);
1094 ASSERT_EQ(ret, "A:U:");
1095 action = AxisEvent::AXIS_ACTION_END;
1096 ret = axisevent.ActionToShortStr(action);
1097 ASSERT_EQ(ret, "A:E:");
1098 action = AxisEvent::AXIS_ACTION_UNKNOWN;
1099 ret = axisevent.ActionToShortStr(action);
1100 ASSERT_EQ(ret, "A:UK:");
1101 action = 10;
1102 ret = axisevent.ActionToShortStr(action);
1103 ASSERT_EQ(ret, "A:?:");
1104 }
1105
1106 /**
1107 * @tc.name: PointerEventTest_AddCapability_001
1108 * @tc.desc: Verify AddCapability
1109 * @tc.type: FUNC
1110 * @tc.require:
1111 * @tc.author:
1112 */
1113 HWTEST_F(PointerEventTest, PointerEventTest_AddCapability_001, TestSize.Level1)
1114 {
1115 CALL_TEST_DEBUG;
1116 InputDevice device;
1117 InputDeviceCapability cap;
1118 cap = INPUT_DEV_CAP_TOUCH;
1119 ASSERT_NO_FATAL_FAILURE(device.AddCapability(cap));
1120 cap = INPUT_DEV_CAP_MAX;
1121 ASSERT_NO_FATAL_FAILURE(device.AddCapability(cap));
1122 }
1123
1124 /**
1125 * @tc.name: PointerEventTest_HasCapability_001
1126 * @tc.desc: Verify HasCapability
1127 * @tc.type: FUNC
1128 * @tc.require:
1129 * @tc.author:
1130 */
1131 HWTEST_F(PointerEventTest, PointerEventTest_HasCapability_001, TestSize.Level1)
1132 {
1133 CALL_TEST_DEBUG;
1134 InputDevice device;
1135 InputDeviceCapability cap;
1136 cap = INPUT_DEV_CAP_TOUCH;
1137 bool ret = device.HasCapability(cap);
1138 ASSERT_FALSE(ret);
1139 cap = INPUT_DEV_CAP_MAX;
1140 ret = device.HasCapability(cap);
1141 ASSERT_FALSE(ret);
1142 }
1143
1144 /**
1145 * @tc.name: PointerEventTest_HasCapability_002
1146 * @tc.desc: Verify HasCapability
1147 * @tc.type: FUNC
1148 * @tc.require:
1149 * @tc.author:
1150 */
1151 HWTEST_F(PointerEventTest, PointerEventTest_HasCapability_002, TestSize.Level1)
1152 {
1153 CALL_TEST_DEBUG;
1154 InputDevice device;
1155 device.capabilities_.set(InputDeviceCapability::INPUT_DEV_CAP_KEYBOARD);
1156 device.capabilities_.set(InputDeviceCapability::INPUT_DEV_CAP_POINTER);
1157 EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD));
1158 EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_POINTER));
1159 EXPECT_FALSE(device.HasCapability(INPUT_DEV_CAP_TOUCH));
1160 EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD | INPUT_DEV_CAP_POINTER | INPUT_DEV_CAP_TOUCH));
1161 EXPECT_TRUE(device.HasCapability(INPUT_DEV_CAP_KEYBOARD | INPUT_DEV_CAP_POINTER));
1162 }
1163
1164 /**
1165 * @tc.name: PointerEventTest_MarkProcessed_001
1166 * @tc.desc: Verify MarkProcessed
1167 * @tc.type: FUNC
1168 * @tc.require:
1169 * @tc.author:
1170 */
1171 HWTEST_F(PointerEventTest, PointerEventTest_MarkProcessed_001, TestSize.Level1)
1172 {
1173 CALL_TEST_DEBUG;
1174 std::function<void(int32_t, int64_t)> processedCallback_;
1175 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1176 inputEvent->markEnabled_ = true;
1177 ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1178 inputEvent->markEnabled_ = false;
1179 ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1180 }
1181
1182 /**
1183 * @tc.name: PointerEventTest_SetExtraData_002
1184 * @tc.desc: Verify SetExtraData
1185 * @tc.type: FUNC
1186 * @tc.require:
1187 * @tc.author:
1188 */
1189 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_002, TestSize.Level1)
1190 {
1191 CALL_TEST_DEBUG;
1192 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1193 std::shared_ptr<const uint8_t[]> data;
1194 uint32_t length = 10;
1195 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(data, length));
1196 }
1197
1198 /**
1199 * @tc.name: PointerEventTest_GetExtraData_002
1200 * @tc.desc: Verify GetExtraData
1201 * @tc.type: FUNC
1202 * @tc.require:
1203 * @tc.author:
1204 */
1205 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_002, TestSize.Level1)
1206 {
1207 CALL_TEST_DEBUG;
1208 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1209 std::shared_ptr<const uint8_t[]> data;
1210 uint32_t length = 10;
1211 inputEvent->extraDataLength_ = 5;
1212 std::shared_ptr<const uint8_t[]> extraData;
1213 inputEvent->extraData_ = extraData;
1214 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1215 }
1216
1217 /**
1218 * @tc.name: PointerEventTest_WriteToParcel_001
1219 * @tc.desc: Verify WriteToParcel
1220 * @tc.type: FUNC
1221 * @tc.require:
1222 * @tc.author:
1223 */
1224 HWTEST_F(PointerEventTest, PointerEventTest_WriteToParcel_001, TestSize.Level1)
1225 {
1226 CALL_TEST_DEBUG;
1227 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1228 Parcel out;
1229 inputEvent->extraDataLength_ = 5;
1230 std::shared_ptr<const uint8_t[]> extraData;
1231 inputEvent->extraData_ = extraData;
1232 bool ret = inputEvent->WriteToParcel(out);
1233 ASSERT_TRUE(ret);
1234 }
1235
1236 /**
1237 * @tc.name: PointerEventTest_ReadFromParcel_001
1238 * @tc.desc: Verify ReadFromParcel
1239 * @tc.type: FUNC
1240 * @tc.require:
1241 * @tc.author:
1242 */
1243 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel_001, TestSize.Level1)
1244 {
1245 CALL_TEST_DEBUG;
1246 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1247 Parcel in;
1248 inputEvent->extraDataLength_ = 1088;
1249 bool ret = inputEvent->ReadFromParcel(in);
1250 ASSERT_FALSE(ret);
1251 inputEvent->extraDataLength_ = 10;
1252 ret = inputEvent->ReadFromParcel(in);
1253 ASSERT_FALSE(ret);
1254 }
1255
1256 /**
1257 * @tc.name: PointerEventTest_ActionToShortStr_002
1258 * @tc.desc: Verify ActionToShortStr
1259 * @tc.type: FUNC
1260 * @tc.require:
1261 * @tc.author:
1262 */
1263 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_002, TestSize.Level1)
1264 {
1265 CALL_TEST_DEBUG;
1266 auto inputEvent = std::make_shared<InputEvent>(InputEvent::EVENT_TYPE_KEY);
1267 int32_t action = InputEvent::ACTION_CANCEL;
1268 auto ret = inputEvent->ActionToShortStr(action);
1269 ASSERT_EQ(ret, "B:C:");
1270 action = InputEvent::ACTION_UNKNOWN;
1271 ret = inputEvent->ActionToShortStr(action);
1272 ASSERT_EQ(ret, "B:UK:");
1273 action = InputEvent::EVENT_FLAG_HIDE_POINTER;
1274 ret = inputEvent->ActionToShortStr(action);
1275 ASSERT_EQ(ret, "B:?:");
1276 }
1277
1278 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
1279 /**
1280 * @tc.name: PointerEventTest_SetFingerprintDistanceX_001
1281 * @tc.desc: Set the fingerprint distance X.
1282 * @tc.type: FUNC
1283 * @tc.require:
1284 */
1285 HWTEST_F(PointerEventTest, PointerEventTest_SetFingerprintDistanceX_001, TestSize.Level1)
1286 {
1287 CALL_TEST_DEBUG;
1288 auto pointerEvent = PointerEvent::Create();
1289 ASSERT_NE(pointerEvent, nullptr);
1290 double x = 10.0;
1291 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetFingerprintDistanceX(x));
1292 ASSERT_EQ(pointerEvent->GetFingerprintDistanceX(), x);
1293 }
1294
1295 /**
1296 * @tc.name: PointerEventTest_SetFingerprintDistanceY_001
1297 * @tc.desc: Set the fingerprint distance Y.
1298 * @tc.type: FUNC
1299 * @tc.require:
1300 */
1301 HWTEST_F(PointerEventTest, PointerEventTest_SetFingerprintDistanceY_001, TestSize.Level1)
1302 {
1303 CALL_TEST_DEBUG;
1304 auto pointerEvent = PointerEvent::Create();
1305 ASSERT_NE(pointerEvent, nullptr);
1306 double y = 10.0;
1307 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetFingerprintDistanceY(y));
1308 ASSERT_EQ(pointerEvent->GetFingerprintDistanceY(), y);
1309 }
1310 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
1311
1312 /**
1313 * @tc.name: PointerEventTest_SetHandlerEventType
1314 * @tc.desc: Verify SetHandlerEventType
1315 * @tc.type: FUNC
1316 * @tc.require:
1317 * @tc.author:
1318 */
1319 HWTEST_F(PointerEventTest, PointerEventTest_SetHandlerEventType, TestSize.Level1)
1320 {
1321 CALL_TEST_DEBUG;
1322 auto pointerEvent = PointerEvent::Create();
1323 ASSERT_NE(pointerEvent, nullptr);
1324 pointerEvent->SetHandlerEventType(0);
1325 ASSERT_EQ(pointerEvent->GetHandlerEventType(), 0);
1326 }
1327
1328 /**
1329 * @tc.name: PointerEventTest_GetAxisValue_001
1330 * @tc.desc: Test the funcation GetAxisValue
1331 * @tc.type: FUNC
1332 * @tc.require:
1333 */
1334 HWTEST_F(PointerEventTest, PointerEventTest_GetAxisValue_001, TestSize.Level1)
1335 {
1336 CALL_TEST_DEBUG;
1337 auto pointerEvent = PointerEvent::Create();
1338 ASSERT_NE(pointerEvent, nullptr);
1339 PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1340 ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1341 axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1342 ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1343 axis = PointerEvent::AXIS_TYPE_PINCH;
1344 ASSERT_NO_FATAL_FAILURE(pointerEvent->GetAxisValue(axis));
1345 }
1346
1347 /**
1348 * @tc.name: PointerEventTest_SetAxisValue_001
1349 * @tc.desc: Test the funcation SetAxisValue
1350 * @tc.type: FUNC
1351 * @tc.require:
1352 */
1353 HWTEST_F(PointerEventTest, PointerEventTest_SetAxisValue_001, TestSize.Level1)
1354 {
1355 CALL_TEST_DEBUG;
1356 auto pointerEvent = PointerEvent::Create();
1357 ASSERT_NE(pointerEvent, nullptr);
1358 double axisValue = 1.0;
1359 PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1360 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1361 axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1362 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1363 axis = PointerEvent::AXIS_TYPE_PINCH;
1364 ASSERT_NO_FATAL_FAILURE(pointerEvent->SetAxisValue(axis, axisValue));
1365 }
1366
1367 /**
1368 * @tc.name: PointerEventTest_HasAxis_001
1369 * @tc.desc: Test the funcation HasAxis
1370 * @tc.type: FUNC
1371 * @tc.require:
1372 */
1373 HWTEST_F(PointerEventTest, PointerEventTest_HasAxis_001, TestSize.Level1)
1374 {
1375 CALL_TEST_DEBUG;
1376 auto pointerEvent = PointerEvent::Create();
1377 ASSERT_NE(pointerEvent, nullptr);
1378 uint32_t axes = 1;
1379 PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1380 bool ret = pointerEvent->HasAxis(axes, axis);
1381 ASSERT_FALSE(ret);
1382 axis = PointerEvent::AXIS_TYPE_UNKNOWN;
1383 ret = pointerEvent->HasAxis(axes, axis);
1384 ASSERT_TRUE(ret);
1385 axis = PointerEvent::AXIS_TYPE_PINCH;
1386 ret = pointerEvent->HasAxis(axes, axis);
1387 ASSERT_FALSE(ret);
1388 }
1389
1390 /**
1391 * @tc.name: PointerEventTest_SetPressure_001
1392 * @tc.desc: Test the funcation SetPressure
1393 * @tc.type: FUNC
1394 * @tc.require:
1395 */
1396 HWTEST_F(PointerEventTest, PointerEventTest_SetPressure_001, TestSize.Level1)
1397 {
1398 CALL_TEST_DEBUG;
1399 double pressure = -1.0;
1400 PointerEvent::PointerItem item;
1401 ASSERT_NO_FATAL_FAILURE(item.SetPressure(pressure));
1402 pressure = 1.0;
1403 ASSERT_NO_FATAL_FAILURE(item.SetPressure(pressure));
1404 }
1405
1406 /**
1407 * @tc.name: PointerEventTest_SetMoveFlag_001
1408 * @tc.desc: Test the funcation SetMoveFlag
1409 * @tc.type: FUNC
1410 * @tc.require:
1411 */
1412 HWTEST_F(PointerEventTest, PointerEventTest_SetMoveFlag_001, TestSize.Level1)
1413 {
1414 CALL_TEST_DEBUG;
1415 int32_t moveFlag = -1;
1416 PointerEvent::PointerItem item;
1417 ASSERT_NO_FATAL_FAILURE(item.SetMoveFlag(moveFlag));
1418 moveFlag = 0;
1419 ASSERT_NO_FATAL_FAILURE(item.SetMoveFlag(moveFlag));
1420 }
1421
1422 /**
1423 * @tc.name: PointerEventTest_ActionToShortStr_003
1424 * @tc.desc: Test the funcation ActionToShortStr
1425 * @tc.type: FUNC
1426 * @tc.require:
1427 */
1428 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_003, TestSize.Level1)
1429 {
1430 CALL_TEST_DEBUG;
1431 auto pointerEvent = PointerEvent::Create();
1432 ASSERT_NE(pointerEvent, nullptr);
1433 int32_t action = PointerEvent::POINTER_ACTION_PULL_UP;
1434 auto ret = pointerEvent->ActionToShortStr(action);
1435 ASSERT_EQ(ret, "P:PU:");
1436 action = PointerEvent::POINTER_ACTION_PULL_IN_WINDOW;
1437 ret = pointerEvent->ActionToShortStr(action);
1438 ASSERT_EQ(ret, "P:PI:");
1439 action = PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW;
1440 ret = pointerEvent->ActionToShortStr(action);
1441 ASSERT_EQ(ret, "P:PO:");
1442 action = PointerEvent::POINTER_ACTION_SWIPE_BEGIN;
1443 ret = pointerEvent->ActionToShortStr(action);
1444 ASSERT_EQ(ret, "P:SB:");
1445 action = PointerEvent::POINTER_ACTION_SWIPE_UPDATE;
1446 ret = pointerEvent->ActionToShortStr(action);
1447 ASSERT_EQ(ret, "P:SU:");
1448 action = PointerEvent::POINTER_ACTION_SWIPE_END;
1449 ret = pointerEvent->ActionToShortStr(action);
1450 ASSERT_EQ(ret, "P:SE:");
1451 action = PointerEvent::POINTER_ACTION_ROTATE_BEGIN;
1452 ret = pointerEvent->ActionToShortStr(action);
1453 ASSERT_EQ(ret, "P:RB:");
1454 action = PointerEvent::POINTER_ACTION_ROTATE_UPDATE;
1455 ret = pointerEvent->ActionToShortStr(action);
1456 ASSERT_EQ(ret, "P:RU:");
1457 action = PointerEvent::POINTER_ACTION_ROTATE_END;
1458 ret = pointerEvent->ActionToShortStr(action);
1459 ASSERT_EQ(ret, "P:RE:");
1460 action = PointerEvent::POINTER_ACTION_TRIPTAP;
1461 ret = pointerEvent->ActionToShortStr(action);
1462 ASSERT_EQ(ret, "P:TT:");
1463 }
1464
1465 /**
1466 * @tc.name: PointerEventTest_ActionToShortStr_004
1467 * @tc.desc: Test the funcation ActionToShortStr
1468 * @tc.type: FUNC
1469 * @tc.require:
1470 */
1471 HWTEST_F(PointerEventTest, PointerEventTest_ActionToShortStr_004, TestSize.Level1)
1472 {
1473 CALL_TEST_DEBUG;
1474 auto pointerEvent = PointerEvent::Create();
1475 ASSERT_NE(pointerEvent, nullptr);
1476 int32_t action = PointerEvent::POINTER_ACTION_QUADTAP;
1477 auto ret = pointerEvent->ActionToShortStr(action);
1478 ASSERT_EQ(ret, "P:Q:");
1479 action = PointerEvent::POINTER_ACTION_HOVER_MOVE;
1480 ret = pointerEvent->ActionToShortStr(action);
1481 ASSERT_EQ(ret, "P:HM:");
1482 action = PointerEvent::POINTER_ACTION_HOVER_ENTER;
1483 ret = pointerEvent->ActionToShortStr(action);
1484 ASSERT_EQ(ret, "P:HE:");
1485 action = PointerEvent::POINTER_ACTION_FINGERPRINT_DOWN;
1486 ret = pointerEvent->ActionToShortStr(action);
1487 ASSERT_EQ(ret, "P:FD:");
1488 action = PointerEvent::POINTER_ACTION_FINGERPRINT_UP;
1489 ret = pointerEvent->ActionToShortStr(action);
1490 ASSERT_EQ(ret, "P:FU:");
1491 action = PointerEvent::POINTER_ACTION_FINGERPRINT_SLIDE;
1492 ret = pointerEvent->ActionToShortStr(action);
1493 ASSERT_EQ(ret, "P:FS:");
1494 action = PointerEvent::POINTER_ACTION_FINGERPRINT_RETOUCH;
1495 ret = pointerEvent->ActionToShortStr(action);
1496 ASSERT_EQ(ret, "P:FR:");
1497 action = PointerEvent::POINTER_ACTION_FINGERPRINT_CLICK;
1498 ret = pointerEvent->ActionToShortStr(action);
1499 ASSERT_EQ(ret, "P:FC:");
1500 action = PointerEvent::POINTER_ACTION_UNKNOWN;
1501 ret = pointerEvent->ActionToShortStr(action);
1502 ASSERT_EQ(ret, "P:UK:");
1503 action = 100;
1504 ret = pointerEvent->ActionToShortStr(action);
1505 ASSERT_EQ(ret, "P:?:");
1506 }
1507
1508 /**
1509 * @tc.name: PointerEventTest_SetTiltX_001
1510 * @tc.desc: Test the funcation SetTiltX and GetTiltX
1511 * @tc.type: FUNC
1512 * @tc.require:
1513 */
1514 HWTEST_F(PointerEventTest, PointerEventTest_SetTiltX_001, TestSize.Level1)
1515 {
1516 CALL_TEST_DEBUG;
1517 double x = 10.0;
1518 PointerEvent::PointerItem item;
1519 ASSERT_NO_FATAL_FAILURE(item.SetTiltX(x));
1520 ASSERT_EQ(item.GetTiltX(), x);
1521 }
1522
1523 /**
1524 * @tc.name: PointerEventTest_SetTiltY_001
1525 * @tc.desc: Test the funcation SetTiltY and GetTiltY
1526 * @tc.type: FUNC
1527 * @tc.require:
1528 */
1529 HWTEST_F(PointerEventTest, PointerEventTest_SetTiltY_001, TestSize.Level1)
1530 {
1531 CALL_TEST_DEBUG;
1532 double y = 10.0;
1533 PointerEvent::PointerItem item;
1534 ASSERT_NO_FATAL_FAILURE(item.SetTiltY(y));
1535 ASSERT_EQ(item.GetTiltY(), y);
1536 }
1537
1538 /**
1539 * @tc.name: PointerEventTest_SetRawDisplayX_001
1540 * @tc.desc: Sets the raw X coordinate.
1541 * @tc.type: FUNC
1542 * @tc.require:
1543 */
1544 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDisplayX_001, TestSize.Level1)
1545 {
1546 CALL_TEST_DEBUG;
1547 int32_t rawDisplayX = 60;
1548 PointerEvent::PointerItem item;
1549 item.SetPointerId(8);
1550 item.SetDownTime(1);
1551 ASSERT_NO_FATAL_FAILURE(item.SetRawDisplayX(rawDisplayX));
1552 ASSERT_EQ(item.GetRawDisplayX(), rawDisplayX);
1553 }
1554
1555 /**
1556 * @tc.name: PointerEventTest_SetRawDisplayY_001
1557 * @tc.desc: Sets the raw Y coordinate.
1558 * @tc.type: FUNC
1559 * @tc.require:
1560 */
1561 HWTEST_F(PointerEventTest, PointerEventTest_SetRawDisplayY_001, TestSize.Level1)
1562 {
1563 CALL_TEST_DEBUG;
1564 int32_t rawDisplayY = 60;
1565 PointerEvent::PointerItem item;
1566 item.SetPointerId(8);
1567 item.SetDownTime(1);
1568 ASSERT_NO_FATAL_FAILURE(item.SetRawDisplayY(rawDisplayY));
1569 ASSERT_EQ(item.GetRawDisplayY(), rawDisplayY);
1570 }
1571
1572 /**
1573 * @tc.name: PointerEventTest_EventTypeToString_001
1574 * @tc.desc: Test the funcation EventTypeToString
1575 * @tc.type: FUNC
1576 * @tc.require:
1577 */
1578 HWTEST_F(PointerEventTest, PointerEventTest_EventTypeToString_001, TestSize.Level1)
1579 {
1580 CALL_TEST_DEBUG;
1581 auto inputEvent = InputEvent::Create();
1582 ASSERT_NE(inputEvent, nullptr);
1583 int32_t eventType = InputEvent::EVENT_TYPE_BASE;
1584 std::string ret = inputEvent->EventTypeToString(eventType);
1585 ASSERT_EQ(ret, "base");
1586 eventType = InputEvent::EVENT_TYPE_KEY;
1587 ret = inputEvent->EventTypeToString(eventType);
1588 ASSERT_EQ(ret, "key");
1589 eventType = InputEvent::EVENT_TYPE_POINTER;
1590 ret = inputEvent->EventTypeToString(eventType);
1591 ASSERT_EQ(ret, "pointer");
1592 eventType = InputEvent::EVENT_TYPE_AXIS;
1593 ret = inputEvent->EventTypeToString(eventType);
1594 ASSERT_EQ(ret, "axis");
1595 eventType = InputEvent::EVENT_TYPE_FINGERPRINT;
1596 ret = inputEvent->EventTypeToString(eventType);
1597 ASSERT_EQ(ret, "fingerprint");
1598 eventType = InputEvent::EVENT_FLAG_NO_INTERCEPT;
1599 ret = inputEvent->EventTypeToString(eventType);
1600 ASSERT_EQ(ret, "unknown");
1601 }
1602
1603 /**
1604 * @tc.name: PointerEventTest_MarkProcessed_002
1605 * @tc.desc: Test the funcation MarkProcessed
1606 * @tc.type: FUNC
1607 * @tc.require:
1608 * @tc.author:
1609 */
1610 HWTEST_F(PointerEventTest, PointerEventTest_MarkProcessed_002, TestSize.Level1)
1611 {
1612 CALL_TEST_DEBUG;
1613 auto inputEvent = InputEvent::Create();
1614 ASSERT_NE(inputEvent, nullptr);
__anon02747d2b0202(int a, int b) 1615 auto callback = [](int a, int b) {};
1616 inputEvent->processedCallback_ = callback;
1617 inputEvent->processedCallback_(10, 20);
1618 inputEvent->markEnabled_ = false;
1619 ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1620 inputEvent->markEnabled_ = true;
1621 ASSERT_NO_FATAL_FAILURE(inputEvent->MarkProcessed());
1622 }
1623
1624 /**
1625 * @tc.name: PointerEventTest_SetExtraData_005
1626 * @tc.desc: Set extra data
1627 * @tc.type: FUNC
1628 * @tc.require:
1629 */
1630 HWTEST_F(PointerEventTest, PointerEventTest_SetExtraData_005, TestSize.Level1)
1631 {
1632 CALL_TEST_DEBUG;
1633 auto inputEvent = InputEvent::Create();
1634 ASSERT_NE(inputEvent, nullptr);
1635 uint32_t length = 5;
1636 uint8_t data[5] = {1, 2, 3, 4, 5};
__anon02747d2b0302(const uint8_t*) 1637 std::shared_ptr<const uint8_t[]> sharedData(data, [](const uint8_t*) {});
1638 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1639 length = -5;
1640 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1641 length = 2000;
1642 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1643 }
1644
1645 /**
1646 * @tc.name: PointerEventTest_GetExtraData_004
1647 * @tc.desc: Verify GetExtraData
1648 * @tc.type: FUNC
1649 * @tc.require:
1650 * @tc.author:
1651 */
1652 HWTEST_F(PointerEventTest, PointerEventTest_GetExtraData_004, TestSize.Level1)
1653 {
1654 CALL_TEST_DEBUG;
1655 auto inputEvent = InputEvent::Create();
1656 ASSERT_NE(inputEvent, nullptr);
1657 uint32_t length = 5;
1658 inputEvent->extraDataLength_ = 5;
1659 std::shared_ptr<const uint8_t[]> data;
1660 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1661 inputEvent->extraDataLength_ = 0;
1662 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1663 uint8_t datas[5] = {1, 2, 3, 4, 5};
__anon02747d2b0402(const uint8_t*) 1664 std::shared_ptr<const uint8_t[]> sharedData(datas, [](const uint8_t*) {});
1665 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1666 inputEvent->extraDataLength_ = 10;
1667 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1668 inputEvent->extraDataLength_ = 0;
1669 ASSERT_NO_FATAL_FAILURE(inputEvent->GetExtraData(data, length));
1670 }
1671
1672 /**
1673 * @tc.name: PointerEventTest_WriteToParcel_003
1674 * @tc.desc: Verify WriteToParcel
1675 * @tc.type: FUNC
1676 * @tc.require:
1677 * @tc.author:
1678 */
1679 HWTEST_F(PointerEventTest, PointerEventTest_WriteToParcel_003, TestSize.Level1)
1680 {
1681 CALL_TEST_DEBUG;
1682 auto inputEvent = InputEvent::Create();
1683 ASSERT_NE(inputEvent, nullptr);
1684 Parcel out;
1685 uint32_t length = 5;
1686 inputEvent->extraDataLength_ = 0;
1687 bool ret = inputEvent->WriteToParcel(out);
1688 ASSERT_TRUE(ret);
1689 inputEvent->extraDataLength_ = 5;
1690 ret = inputEvent->WriteToParcel(out);
1691 ASSERT_TRUE(ret);
1692 uint8_t datas[5] = {1, 2, 3, 4, 5};
__anon02747d2b0502(const uint8_t*) 1693 std::shared_ptr<const uint8_t[]> sharedData(datas, [](const uint8_t*) {});
1694 ASSERT_NO_FATAL_FAILURE(inputEvent->SetExtraData(sharedData, length));
1695 inputEvent->extraDataLength_ = 0;
1696 ret = inputEvent->WriteToParcel(out);
1697 ASSERT_TRUE(ret);
1698 inputEvent->extraDataLength_ = 5;
1699 ret = inputEvent->WriteToParcel(out);
1700 ASSERT_TRUE(ret);
1701 }
1702
1703 /**
1704 * @tc.name: PointerEventTest_ToString
1705 * @tc.desc: Test the funcation ToString
1706 * @tc.type: FUNC
1707 * @tc.require:
1708 */
1709 HWTEST_F(PointerEventTest, PointerEventTest_ToString, TestSize.Level1)
1710 {
1711 CALL_TEST_DEBUG;
1712 auto pointerEvent = PointerEvent::Create();
1713 ASSERT_NE(pointerEvent, nullptr);
1714 ASSERT_NO_FATAL_FAILURE(pointerEvent->ToString());
1715
1716 auto inputEvent = InputEvent::Create();
1717 ASSERT_NE(inputEvent, nullptr);
1718 ASSERT_NO_FATAL_FAILURE(inputEvent->ToString());
1719 }
1720
1721 /**
1722 * @tc.name: PointerEventTest_ReadFromParcel
1723 * @tc.desc: Test the funcation ReadFromParcel
1724 * @tc.type: FUNC
1725 * @tc.require:
1726 */
1727 HWTEST_F(PointerEventTest, PointerEventTest_ReadFromParcel, TestSize.Level1)
1728 {
1729 CALL_TEST_DEBUG;
1730 Parcel in;
1731 PointerEvent::PointerItem item;
1732 item.pressed_ = false;
1733 bool ret = item.ReadFromParcel(in);
1734 ASSERT_FALSE(ret);
1735 }
1736
1737 /**
1738 * @tc.name: PointerEventTest_ClearAxisStatus
1739 * @tc.desc: Test the funcation ClearAxisStatus
1740 * @tc.type: FUNC
1741 * @tc.require:
1742 */
1743 HWTEST_F(PointerEventTest, PointerEventTest_ClearAxisStatus, TestSize.Level1)
1744 {
1745 CALL_TEST_DEBUG;
1746 auto pointerEvent = PointerEvent::Create();
1747 ASSERT_NE(pointerEvent, nullptr);
1748 PointerEvent::AxisType axis = PointerEvent::AXIS_TYPE_MAX;
1749 ASSERT_NO_FATAL_FAILURE(pointerEvent->ClearAxisStatus(axis));
1750 }
1751
1752 /**
1753 * @tc.name: PointerEventTest_from
1754 * @tc.desc: Verify the funcation from
1755 * @tc.type: FUNC
1756 * @tc.require:
1757 * @tc.author:
1758 */
1759 HWTEST_F(PointerEventTest, PointerEventTest_from, TestSize.Level1)
1760 {
1761 CALL_TEST_DEBUG;
1762 auto inputEvent = InputEvent::Create();
1763 ASSERT_NE(inputEvent, nullptr);
1764 ASSERT_NO_FATAL_FAILURE(PointerEvent::from(inputEvent));
1765 }
1766
1767 /**
1768 * @tc.name: PointerEventTest_GetBlobId
1769 * @tc.desc: Verify the funcation GetBlobId
1770 * @tc.type: FUNC
1771 * @tc.require:
1772 * @tc.author:
1773 */
1774 HWTEST_F(PointerEventTest, PointerEventTest_GetBlobId, TestSize.Level1)
1775 {
1776 CALL_TEST_DEBUG;
1777 auto inputEvent = InputEvent::Create();
1778 ASSERT_NE(inputEvent, nullptr);
1779 auto item = PointerEvent::PointerItem();
1780 item.blobId_ = 0;
1781 int32_t bloBid = item.GetBlobId();
1782 ASSERT_EQ(bloBid, item.blobId_);
1783 }
1784
1785 /**
1786 * @tc.name: PointerEventTest_SetBlobId
1787 * @tc.desc: Verify the funcation SetBlobId
1788 * @tc.type: FUNC
1789 * @tc.require:
1790 * @tc.author:
1791 */
1792 HWTEST_F(PointerEventTest, PointerEventTest_SetBlobId, TestSize.Level1)
1793 {
1794 CALL_TEST_DEBUG;
1795 auto inputEvent = InputEvent::Create();
1796 ASSERT_NE(inputEvent, nullptr);
1797 auto item = PointerEvent::PointerItem();
1798 item.SetBlobId(32);
1799 ASSERT_EQ(32, item.blobId_);
1800 }
1801
1802 /**
1803 * @tc.name: PointerEventTest_IsCanceled
1804 * @tc.desc: Verify the funcation IsCanceled
1805 * @tc.type: FUNC
1806 * @tc.require:
1807 * @tc.author:
1808 */
1809 HWTEST_F(PointerEventTest, PointerEventTest_IsCanceled, TestSize.Level1)
1810 {
1811 CALL_TEST_DEBUG;
1812 auto item = PointerEvent::PointerItem();
1813 item.SetCanceled(true);
1814 ASSERT_TRUE(item.IsCanceled());
1815 }
1816
1817 /**
1818 * @tc.name: PointerEventTest_GetFixedDisplayX
1819 * @tc.desc: Verify the funcation FixedDisplayX
1820 * @tc.type: FUNC
1821 * @tc.require:
1822 * @tc.author:
1823 */
1824 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedDisplayX, TestSize.Level1)
1825 {
1826 CALL_TEST_DEBUG;
1827 auto item = PointerEvent::PointerItem();
1828 uint32_t disPlayX = 25;
1829 item.SetFixedDisplayX(disPlayX);
1830 ASSERT_EQ(item.GetFixedDisplayX(), disPlayX);
1831 }
1832
1833 /**
1834 * @tc.name: PointerEventTest_GetFixedDisplayY
1835 * @tc.desc: Verify the funcation FixedDisplayY
1836 * @tc.type: FUNC
1837 * @tc.require:
1838 * @tc.author:
1839 */
1840 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedDisplayY, TestSize.Level1)
1841 {
1842 CALL_TEST_DEBUG;
1843 auto item = PointerEvent::PointerItem();
1844 uint32_t disPlayY = 30;
1845 item.SetFixedDisplayX(disPlayY);
1846 ASSERT_EQ(item.GetFixedDisplayX(), disPlayY);
1847 }
1848
1849 /**
1850 * @tc.name: PointerEventTest_ClearAxisStatus_01
1851 * @tc.desc: Verify the funcation ClearAxisStatus
1852 * @tc.type: FUNC
1853 * @tc.require:
1854 * @tc.author:
1855 */
1856 HWTEST_F(PointerEventTest, PointerEventTest_ClearAxisStatus_01, TestSize.Level1)
1857 {
1858 CALL_TEST_DEBUG;
1859 auto pointer = PointerEvent::Create();
1860 PointerEvent::AxisType axisType = PointerEvent::AxisType::AXIS_TYPE_SCROLL_VERTICAL;
1861 ASSERT_NO_FATAL_FAILURE(pointer->SetAxisEventType(axisType));
1862 ASSERT_NO_FATAL_FAILURE(pointer->ClearAxisStatus(axisType));
1863 }
1864
1865 /**
1866 * @tc.name: PointerEventTest_SetVelocity
1867 * @tc.desc: Verify the funcation SetVelocity
1868 * @tc.type: FUNC
1869 * @tc.require:
1870 * @tc.author:
1871 */
1872 HWTEST_F(PointerEventTest, PointerEventTest_SetVelocity, TestSize.Level1)
1873 {
1874 CALL_TEST_DEBUG;
1875 auto pointer = PointerEvent::Create();
1876 double velocity = 8.0;
1877 ASSERT_NO_FATAL_FAILURE(pointer->SetVelocity(velocity));
1878 ASSERT_EQ(pointer->GetVelocity(), velocity);
1879 }
1880
1881 /**
1882 * @tc.name: PointerEventTest_SetHandOption
1883 * @tc.desc: Verify the funcation SetHandOption
1884 * @tc.type: FUNC
1885 * @tc.require:
1886 * @tc.author:
1887 */
1888 HWTEST_F(PointerEventTest, PointerEventTest_SetHandOption, TestSize.Level1)
1889 {
1890 CALL_TEST_DEBUG;
1891 auto pointer = PointerEvent::Create();
1892 int32_t handOption = 5;
1893 ASSERT_NO_FATAL_FAILURE(pointer->SetHandOption(handOption));
1894 ASSERT_EQ(pointer->GetHandOption(), handOption);
1895 }
1896
1897 /**
1898 * @tc.name: PointerEventTest_SetOriginPointerAction
1899 * @tc.desc: Verify the funcation SetOriginPointerAction
1900 * @tc.type: FUNC
1901 * @tc.require:
1902 * @tc.author:
1903 */
1904 HWTEST_F(PointerEventTest, PointerEventTest_SetOriginPointerAction, TestSize.Level1)
1905 {
1906 CALL_TEST_DEBUG;
1907 auto pointer = PointerEvent::Create();
1908 int32_t handOption = 5;
1909 ASSERT_NO_FATAL_FAILURE(pointer->SetOriginPointerAction(handOption));
1910 ASSERT_EQ(pointer->GetOriginPointerAction(), handOption);
1911 }
1912
1913 /**
1914 * @tc.name: PointerEventTest_SetPullId
1915 * @tc.desc: Verify the funcation SetPullId
1916 * @tc.type: FUNC
1917 * @tc.require:
1918 * @tc.author:
1919 */
1920 HWTEST_F(PointerEventTest, PointerEventTest_SetPullId, TestSize.Level1)
1921 {
1922 CALL_TEST_DEBUG;
1923 auto pointer = PointerEvent::Create();
1924 int32_t pullId = 5;
1925 ASSERT_NO_FATAL_FAILURE(pointer->SetPullId(pullId));
1926 ASSERT_EQ(pointer->GetPullId(), pullId);
1927 }
1928
1929 /**
1930 * @tc.name: PointerEventTest_SetScrollRows
1931 * @tc.desc: Verify the funcation SetScrollRows
1932 * @tc.type: FUNC
1933 * @tc.require:
1934 * @tc.author:
1935 */
1936 HWTEST_F(PointerEventTest, PointerEventTest_SetScrollRows, TestSize.Level1)
1937 {
1938 CALL_TEST_DEBUG;
1939 auto pointer = PointerEvent::Create();
1940 int32_t scrollRows = 5;
1941 ASSERT_NO_FATAL_FAILURE(pointer->SetScrollRows(scrollRows));
1942 ASSERT_EQ(pointer->GetScrollRows(), scrollRows);
1943 }
1944
1945 /**
1946 * @tc.name: PointerEventTest_SetFixedMode
1947 * @tc.desc: Verify the funcation SetFixedMode
1948 * @tc.type: FUNC
1949 * @tc.require:
1950 * @tc.author:
1951 */
1952 HWTEST_F(PointerEventTest, PointerEventTest_SetFixedMode, TestSize.Level1)
1953 {
1954 CALL_TEST_DEBUG;
1955 auto pointer = PointerEvent::Create();
1956 auto fixedMode = PointerEvent::FixedMode::SCREEN_MODE_MAX;
1957 ASSERT_NO_FATAL_FAILURE(pointer->SetFixedMode(fixedMode));
1958 ASSERT_EQ(pointer->GetFixedMode(), fixedMode);
1959 }
1960
1961 /**
1962 * @tc.name: PointerEventTest_GetFixedModeStr
1963 * @tc.desc: Verify the funcation GetFixedModeStr
1964 * @tc.type: FUNC
1965 * @tc.require:
1966 * @tc.author:
1967 */
1968 HWTEST_F(PointerEventTest, PointerEventTest_GetFixedModeStr, TestSize.Level1)
1969 {
1970 CALL_TEST_DEBUG;
1971 auto pointer = PointerEvent::Create();
1972 auto fixedMode = PointerEvent::FixedMode::SCREEN_MODE_MAX;
1973 ASSERT_NO_FATAL_FAILURE(pointer->SetFixedMode(fixedMode));
1974 ASSERT_EQ(pointer->GetFixedModeStr(), "unknown");
1975 fixedMode = PointerEvent::FixedMode::NORMAL;
1976 pointer->SetFixedMode(fixedMode);
1977 ASSERT_EQ(pointer->GetFixedModeStr(), "normal");
1978 fixedMode = PointerEvent::FixedMode::ONE_HAND;
1979 pointer->SetFixedMode(fixedMode);
1980 ASSERT_EQ(pointer->GetFixedModeStr(), "one-hand");
1981 }
1982
1983 /**
1984 * @tc.name: PointerEventTest_SetProcessedCallback
1985 * @tc.desc: Verify the funcation SetProcessedCallback
1986 * @tc.type: FUNC
1987 * @tc.require:
1988 * @tc.author:
1989 */
1990 HWTEST_F(PointerEventTest, PointerEventTest_SetProcessedCallback, TestSize.Level1)
1991 {
1992 CALL_TEST_DEBUG;
1993 auto inputEvent = InputEvent::Create();
1994 ASSERT_NO_FATAL_FAILURE(inputEvent->SetProcessedCallback(MyCallback));
1995 }
1996
1997 /**
1998 * @tc.name: PointerEventTest_DumpPointerAction_001
1999 * @tc.desc: Verify the funcation DumpPointerAction
2000 * @tc.type: FUNC
2001 * @tc.require:
2002 * @tc.author:
2003 */
2004 HWTEST_F(PointerEventTest, PointerEventTest_DumpPointerAction_001, TestSize.Level1)
2005 {
2006 CALL_TEST_DEBUG;
2007 auto pointerEvent = PointerEvent::Create();
2008 ASSERT_NE(pointerEvent, nullptr);
2009 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN);
2010 double axisValue = 0;
2011 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, axisValue);
2012 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2013
2014 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL, axisValue);
2015 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2016
2017 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, axisValue);
2018 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2019
2020 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_ROTATE, axisValue);
2021 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2022 }
2023
2024 /**
2025 * @tc.name: PointerEventTest_DumpPointerAction_002
2026 * @tc.desc: Verify the funcation DumpPointerAction
2027 * @tc.type: FUNC
2028 * @tc.require:
2029 * @tc.author:
2030 */
2031 HWTEST_F(PointerEventTest, PointerEventTest_DumpPointerAction_002, TestSize.Level1)
2032 {
2033 CALL_TEST_DEBUG;
2034 auto pointerEvent = PointerEvent::Create();
2035 ASSERT_NE(pointerEvent, nullptr);
2036 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
2037 double axisValue = 0;
2038 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, axisValue);
2039 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2040
2041 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL, axisValue);
2042 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2043
2044 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, axisValue);
2045 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2046
2047 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_ROTATE, axisValue);
2048 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2049 }
2050
2051 /**
2052 * @tc.name: PointerEventTest_DumpPointerAction_003
2053 * @tc.desc: Verify the funcation DumpPointerAction
2054 * @tc.type: FUNC
2055 * @tc.require:
2056 * @tc.author:
2057 */
2058 HWTEST_F(PointerEventTest, PointerEventTest_DumpPointerAction_003, TestSize.Level1)
2059 {
2060 CALL_TEST_DEBUG;
2061 auto pointerEvent = PointerEvent::Create();
2062 ASSERT_NE(pointerEvent, nullptr);
2063 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
2064 double axisValue = 0;
2065 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, axisValue);
2066 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2067
2068 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL, axisValue);
2069 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2070
2071 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, axisValue);
2072 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2073
2074 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_ROTATE, axisValue);
2075 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2076 }
2077
2078 /**
2079 * @tc.name: PointerEventTest_DumpPointerAction_004
2080 * @tc.desc: Verify the funcation DumpPointerAction
2081 * @tc.type: FUNC
2082 * @tc.require:
2083 * @tc.author:
2084 */
2085 HWTEST_F(PointerEventTest, PointerEventTest_DumpPointerAction_004, TestSize.Level1)
2086 {
2087 CALL_TEST_DEBUG;
2088 auto pointerEvent = PointerEvent::Create();
2089 ASSERT_NE(pointerEvent, nullptr);
2090 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
2091 ASSERT_NO_FATAL_FAILURE(pointerEvent->DumpPointerAction());
2092 }
2093
2094 /**
2095 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_001
2096 * @tc.desc: Verify if (pointers_.size() != 1)
2097 * @tc.type: FUNC
2098 * @tc.require:
2099 * @tc.author:
2100 */
2101 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_001, TestSize.Level1)
2102 {
2103 CALL_TEST_DEBUG;
2104 auto pointerEvent = PointerEvent::Create();
2105 ASSERT_NE(pointerEvent, nullptr);
2106 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2107 }
2108
2109 /**
2110 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_002
2111 * @tc.desc: Verify if (pointers_.size() != 1)
2112 * @tc.type: FUNC
2113 * @tc.require:
2114 * @tc.author:
2115 */
2116 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_002, TestSize.Level1)
2117 {
2118 CALL_TEST_DEBUG;
2119 auto pointerEvent = PointerEvent::Create();
2120 ASSERT_NE(pointerEvent, nullptr);
2121 PointerEvent::PointerItem item;
2122 pointerEvent->AddPointerItem(item);
2123 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2124 }
2125
2126 /**
2127 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_003
2128 * @tc.desc: Verify if (pressedButtons_.size() > maxPressedButtons)
2129 * @tc.type: FUNC
2130 * @tc.require:
2131 * @tc.author:
2132 */
2133 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_003, TestSize.Level1)
2134 {
2135 CALL_TEST_DEBUG;
2136 auto pointerEvent = PointerEvent::Create();
2137 ASSERT_NE(pointerEvent, nullptr);
2138 PointerEvent::PointerItem item;
2139 pointerEvent->AddPointerItem(item);
2140 pointerEvent->SetButtonPressed(0);
2141 pointerEvent->SetButtonPressed(1);
2142 pointerEvent->SetButtonPressed(2);
2143 pointerEvent->SetButtonPressed(3);
2144 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2145 }
2146
2147 /**
2148 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_004
2149 * @tc.desc: Verify if (pressedButtons_.size() > maxPressedButtons)
2150 * @tc.type: FUNC
2151 * @tc.require:
2152 * @tc.author:
2153 */
2154 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_004, TestSize.Level1)
2155 {
2156 CALL_TEST_DEBUG;
2157 auto pointerEvent = PointerEvent::Create();
2158 ASSERT_NE(pointerEvent, nullptr);
2159 PointerEvent::PointerItem item;
2160 pointerEvent->AddPointerItem(item);
2161 pointerEvent->SetButtonPressed(0);
2162 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2163 }
2164
2165 /**
2166 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_005
2167 * @tc.desc: Verify if (checkFlag)
2168 * @tc.type: FUNC
2169 * @tc.require:
2170 * @tc.author:
2171 */
2172 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_005, TestSize.Level1)
2173 {
2174 CALL_TEST_DEBUG;
2175 auto pointerEvent = PointerEvent::Create();
2176 ASSERT_NE(pointerEvent, nullptr);
2177 PointerEvent::PointerItem item;
2178 pointerEvent->AddPointerItem(item);
2179 pointerEvent->SetButtonPressed(0);
2180 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
2181 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2182 }
2183
2184 /**
2185 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_006
2186 * @tc.desc: Verify if (checkFlag)
2187 * @tc.type: FUNC
2188 * @tc.require:
2189 * @tc.author:
2190 */
2191 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_006, TestSize.Level1)
2192 {
2193 CALL_TEST_DEBUG;
2194 auto pointerEvent = PointerEvent::Create();
2195 ASSERT_NE(pointerEvent, nullptr);
2196 PointerEvent::PointerItem item;
2197 pointerEvent->AddPointerItem(item);
2198 pointerEvent->SetButtonPressed(0);
2199 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2200 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2201 }
2202
2203 /**
2204 * @tc.name: PointerEventTest_IsValidCheckMouseFunc_007
2205 * @tc.desc: Verify if (buttonId != BUTTON_NONE)
2206 * @tc.type: FUNC
2207 * @tc.require:
2208 * @tc.author:
2209 */
2210 HWTEST_F(PointerEventTest, PointerEventTest_IsValidCheckMouseFunc_007, TestSize.Level1)
2211 {
2212 CALL_TEST_DEBUG;
2213 auto pointerEvent = PointerEvent::Create();
2214 ASSERT_NE(pointerEvent, nullptr);
2215 PointerEvent::PointerItem item;
2216 pointerEvent->AddPointerItem(item);
2217 pointerEvent->SetButtonPressed(-1);
2218 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2219 ASSERT_NO_FATAL_FAILURE(pointerEvent->IsValidCheckMouseFunc());
2220 }
2221
2222 /**
2223 * @tc.name: PointerEventTest_SetAngle_001
2224 * @tc.desc: SetAngle
2225 * @tc.type: FUNC
2226 * @tc.require:
2227 * @tc.author:
2228 */
2229 HWTEST_F(PointerEventTest, PointerEventTest_SetAngle_001, TestSize.Level1)
2230 {
2231 CALL_TEST_DEBUG;
2232 auto pointerEvent = PointerEvent::Create();
2233 ASSERT_NE(pointerEvent, nullptr);
2234 PointerEvent::PointerItem item;
2235 int32_t angle = 3;
2236 ASSERT_NO_FATAL_FAILURE(item.SetAngle(angle));
2237 }
2238
2239 /**
2240 * @tc.name: PointerEventTest_GetAngle_001
2241 * @tc.desc: GetAngle
2242 * @tc.type: FUNC
2243 * @tc.require:
2244 * @tc.author:
2245 */
2246 HWTEST_F(PointerEventTest, PointerEventTest_GetAngle_001, TestSize.Level1)
2247 {
2248 CALL_TEST_DEBUG;
2249 auto pointerEvent = PointerEvent::Create();
2250 ASSERT_NE(pointerEvent, nullptr);
2251 PointerEvent::PointerItem item;
2252 int32_t angle = 3;
2253 ASSERT_NO_FATAL_FAILURE(item.SetAngle(angle));
2254 int32_t ret = item.GetAngle();
2255 ASSERT_EQ(ret, angle);
2256 }
2257 } // namespace MMI
2258 } // namespace OHOS
2259