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 "define_multimodal.h"
17 #include "event_util_test.h"
18 #include "proto.h"
19 #include "util.h"
20
21 namespace OHOS {
22 namespace MMI {
23 namespace {
24 #ifdef OHOS_BUILD_ENABLE_POINTER
25 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, MMI_LOG_DOMAIN, "PointerEventTest"};
26 #endif // OHOS_BUILD_ENABLE_POINTER
27 using namespace testing::ext;
28 } // namespace
29 class PointerEventTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
TearDownTestCase(void)32 static void TearDownTestCase(void) {}
33 static std::shared_ptr<PointerEvent> CreatePointEvent();
34 };
35
SetUpTestCase()36 void PointerEventTest::SetUpTestCase()
37 {
38 ASSERT_TRUE(TestUtil->Init());
39 }
40
41 #ifdef OHOS_BUILD_ENABLE_POINTER
CreatePointEvent()42 std::shared_ptr<PointerEvent> PointerEventTest::CreatePointEvent()
43 {
44 auto pointerEvent = PointerEvent::Create();
45 CHKPP(pointerEvent);
46 int64_t downTime = GetMillisTime();
47 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
48 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
49 pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
50 pointerEvent->SetPointerId(1);
51 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
52 PointerEvent::PointerItem item;
53 item.SetPointerId(1);
54 item.SetDownTime(downTime);
55 item.SetPressed(true);
56
57 item.SetDisplayX(623);
58 item.SetDisplayY(823);
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
70 /**
71 * @tc.name: PointerEventTest_keyEventAndPointerEvent_001
72 * @tc.desc: Verify ctrl(left) + point event
73 * @tc.type: FUNC
74 * @tc.require: AR000GOACS
75 * @tc.author: yangguang
76 */
77 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_001, TestSize.Level1)
78 {
79 std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
80 ASSERT_TRUE(pointerEvent != nullptr);
81 std::vector<int32_t> pressedKeys { KeyEvent::KEYCODE_CTRL_LEFT };
82 pointerEvent->SetPressedKeys(pressedKeys);
83 TestSimulateInputEvent(pointerEvent);
84 }
85
86 /**
87 * @tc.name: PointerEventTest_keyEventAndPointerEvent_002
88 * @tc.desc: Verify ctrl(right) + point event
89 * @tc.type: FUNC
90 * @tc.require: AR000GOACS
91 * @tc.author: yangguang
92 */
93 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_002, TestSize.Level1)
94 {
95 std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
96 ASSERT_TRUE(pointerEvent != nullptr);
97 std::vector<int32_t> pressedKeys { KeyEvent::KEYCODE_CTRL_RIGHT };
98 pointerEvent->SetPressedKeys(pressedKeys);
99 TestSimulateInputEvent(pointerEvent);
100 }
101
102 /**
103 * @tc.name: PointerEventTest_keyEventAndPointerEvent_003
104 * @tc.desc: Verify ctrl(left and right) + point event
105 * @tc.type: FUNC
106 * @tc.require: AR000GOACS
107 * @tc.author: yangguang
108 */
109 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_003, TestSize.Level1)
110 {
111 std::shared_ptr<PointerEvent> pointerEvent = CreatePointEvent();
112 ASSERT_TRUE(pointerEvent != nullptr);
113 std::vector<int32_t> pressedKeys { KeyEvent::KEYCODE_CTRL_LEFT, KeyEvent::KEYCODE_CTRL_RIGHT };
114 pointerEvent->SetPressedKeys(pressedKeys);
115 TestSimulateInputEvent(pointerEvent);
116 }
117 #endif // OHOS_BUILD_ENABLE_POINTER
118
119 /**
120 * @tc.name: PointerEventTest_CheckMousePointEvent_001
121 * @tc.desc: Verify mouse point event
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_001, TestSize.Level1)
126 {
127 auto pointerEvent = PointerEvent::Create();
128 ASSERT_NE(pointerEvent, nullptr);
129 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
130 ASSERT_TRUE(!pointerEvent->IsValid());
131
132 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
133 pointerEvent->SetPointerId(-1);
134 ASSERT_TRUE(!pointerEvent->IsValid());
135
136 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
137 pointerEvent->SetPointerId(0);
138 PointerEvent::PointerItem item1;
139 item1.SetPointerId(0);
140 pointerEvent->AddPointerItem(item1);
141 PointerEvent::PointerItem item2;
142 item2.SetPointerId(0);
143 pointerEvent->AddPointerItem(item2);
144 ASSERT_TRUE(!pointerEvent->IsValid());
145 PointerEvent::PointerItem item3;
146 item3.SetPointerId(0);
147 pointerEvent->AddPointerItem(item3);
148 PointerEvent::PointerItem item4;
149 item4.SetPointerId(0);
150 pointerEvent->AddPointerItem(item4);
151 PointerEvent::PointerItem item5;
152 item5.SetPointerId(0);
153 pointerEvent->AddPointerItem(item5);
154 PointerEvent::PointerItem item6;
155 item6.SetPointerId(0);
156 pointerEvent->AddPointerItem(item6);
157
158 auto pointerEvent1 = PointerEvent::Create();
159 ASSERT_NE(pointerEvent1, nullptr);
160 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
161 pointerEvent1->SetPointerId(0);
162 pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
163 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
164 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_RIGHT);
165 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_MIDDLE);
166 item1.SetPointerId(0);
167 pointerEvent1->AddPointerItem(item1);
168 ASSERT_TRUE(!pointerEvent1->IsValid());
169 }
170
171 /**
172 * @tc.name: PointerEventTest_CheckMousePointEvent_002
173 * @tc.desc: Verify mouse point event
174 * @tc.type: FUNC
175 * @tc.require:
176 */
177 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_002, TestSize.Level1)
178 {
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::BUTTON_NONE);
184 PointerEvent::PointerItem item;
185 item.SetPointerId(0);
186 pointerEvent1->AddPointerItem(item);
187 ASSERT_TRUE(!pointerEvent1->IsValid());
188
189 auto pointerEvent2 = PointerEvent::Create();
190 ASSERT_NE(pointerEvent2, nullptr);
191 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
192 pointerEvent2->SetPointerId(0);
193 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
194 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
195 item.SetPointerId(0);
196 pointerEvent2->AddPointerItem(item);
197 ASSERT_TRUE(!pointerEvent2->IsValid());
198
199 auto pointerEvent3 = PointerEvent::Create();
200 ASSERT_NE(pointerEvent3, nullptr);
201 pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
202 pointerEvent3->SetPointerId(0);
203 pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
204 pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
205 pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
206 item.SetPointerId(0);
207 pointerEvent3->AddPointerItem(item);
208 ASSERT_TRUE(!pointerEvent3->IsValid());
209 }
210
211 /**
212 * @tc.name: PointerEventTest_CheckMousePointEvent_003
213 * @tc.desc: Verify mouse point event
214 * @tc.type: FUNC
215 * @tc.require:
216 */
217 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_003, TestSize.Level1)
218 {
219 auto pointerEvent1 = PointerEvent::Create();
220 ASSERT_NE(pointerEvent1, nullptr);
221 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
222 pointerEvent1->SetPointerId(0);
223 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
224 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
225 pointerEvent1->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
226 PointerEvent::PointerItem item;
227 item.SetPointerId(0);
228 pointerEvent1->AddPointerItem(item);
229 ASSERT_TRUE(!pointerEvent1->IsValid());
230
231 auto pointerEvent2 = PointerEvent::Create();
232 ASSERT_NE(pointerEvent2, nullptr);
233 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
234 pointerEvent2->SetPointerId(0);
235 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
236 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
237 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
238 item.SetPointerId(-1);
239 pointerEvent2->AddPointerItem(item);
240 ASSERT_TRUE(!pointerEvent2->IsValid());
241 }
242
243 /**
244 * @tc.name: PointerEventTest_CheckMousePointEvent_004
245 * @tc.desc: Verify mouse point event
246 * @tc.type: FUNC
247 * @tc.require:
248 */
249 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_004, TestSize.Level1)
250 {
251 auto pointerEvent1 = PointerEvent::Create();
252 ASSERT_NE(pointerEvent1, nullptr);
253 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
254 pointerEvent1->SetPointerId(0);
255 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
256 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
257 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
258 PointerEvent::PointerItem item;
259 item.SetPointerId(2);
260 pointerEvent1->AddPointerItem(item);
261 ASSERT_TRUE(!pointerEvent1->IsValid());
262
263 auto pointerEvent2 = PointerEvent::Create();
264 ASSERT_NE(pointerEvent2, nullptr);
265 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
266 pointerEvent2->SetPointerId(0);
267 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
268 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
269 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
270 item.SetPointerId(0);
271 item.SetDownTime(10010);
272 pointerEvent2->AddPointerItem(item);
273 ASSERT_TRUE(!pointerEvent2->IsValid());
274
275 auto pointerEvent3 = PointerEvent::Create();
276 ASSERT_NE(pointerEvent3, nullptr);
277 pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
278 pointerEvent3->SetPointerId(0);
279 pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
280 pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
281 pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
282 item.SetPointerId(0);
283 item.SetDownTime(0);
284 item.SetPressed(true);
285 pointerEvent3->AddPointerItem(item);
286 ASSERT_TRUE(!pointerEvent3->IsValid());
287 }
288
289 /**
290 * @tc.name: PointerEventTest_CheckMousePointEvent_005
291 * @tc.desc: Verify mouse point event
292 * @tc.type: FUNC
293 * @tc.require:
294 */
295 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_005, TestSize.Level1)
296 {
297 auto pointerEvent = PointerEvent::Create();
298 ASSERT_NE(pointerEvent, nullptr);
299 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
300 pointerEvent->SetPointerId(0);
301 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
302 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
303 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
304 PointerEvent::PointerItem item;
305 item.SetPointerId(0);
306 item.SetDownTime(0);
307 item.SetPressed(false);
308 pointerEvent->AddPointerItem(item);
309 ASSERT_TRUE(pointerEvent->IsValid());
310 }
311
312 /**
313 * @tc.name: PointerEventTest_CheckMousePointEvent_006
314 * @tc.desc: Verify mouse point event
315 * @tc.type: FUNC
316 * @tc.require:
317 */
318 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_006, TestSize.Level1)
319 {
320 auto inputEvent = InputEvent::Create();
321 ASSERT_NE(inputEvent, nullptr);
322 inputEvent->SetDeviceId(1);
323 inputEvent->SetTargetWindowId(1);
324 inputEvent->SetAgentWindowId(1);
325 auto event = PointerEvent::from(inputEvent);
326 ASSERT_EQ(event, nullptr);
327
328 auto pointerEvent = PointerEvent::Create();
329 ASSERT_NE(pointerEvent, nullptr);
330 pointerEvent->Reset();
331 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
332 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
333 pointerEvent->SetPointerId(0);
334 pointerEvent->SetDeviceId(inputEvent->GetDeviceId());
335 pointerEvent->SetTargetWindowId(inputEvent->GetTargetWindowId());
336 pointerEvent->SetAgentWindowId(inputEvent->GetAgentWindowId());
337 PointerEvent::PointerItem item1;
338 item1.SetPointerId(0);
339 item1.SetDownTime(0);
340 item1.SetPressed(true);
341 item1.SetWindowX(10);
342 item1.SetWindowY(10);
343 item1.SetDeviceId(inputEvent->GetDeviceId());
344 item1.SetRawDx(60);
345 item1.SetRawDy(60);
346 pointerEvent->AddPointerItem(item1);
347 PointerEvent::PointerItem item2;
348 item2.SetPointerId(1);
349 item2.SetDownTime(0);
350 item2.SetPressed(false);
351 item2.SetWindowX(item1.GetWindowX());
352 item2.SetWindowY(item1.GetWindowY());
353 item2.SetDeviceId(inputEvent->GetDeviceId());
354 item2.SetRawDx(100);
355 item2.SetRawDy(100);
356 pointerEvent->AddPointerItem(item2);
357 ASSERT_TRUE(pointerEvent != nullptr);
358 #ifdef OHOS_BUILD_ENABLE_POINTER
359 TestSimulateInputEvent(pointerEvent);
360 #endif // OHOS_BUILD_ENABLE_POINTER
361 }
362
363 /**
364 * @tc.name: PointerEventTest_CheckTouchPointEvent_001
365 * @tc.desc: Verify touch screen event
366 * @tc.type: FUNC
367 * @tc.require:
368 */
369 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_001, TestSize.Level1)
370 {
371 auto pointerEvent = PointerEvent::Create();
372 ASSERT_NE(pointerEvent, nullptr);
373 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
374 pointerEvent->SetPointerId(-1);
375 ASSERT_TRUE(!pointerEvent->IsValid());
376
377 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
378 pointerEvent->SetPointerId(0);
379 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
380 ASSERT_TRUE(!pointerEvent->IsValid());
381
382 auto pointerEvent1 = PointerEvent::Create();
383 ASSERT_NE(pointerEvent1, nullptr);
384 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
385 pointerEvent1->SetPointerId(0);
386 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
387 ASSERT_TRUE(!pointerEvent1->IsValid());
388
389 auto pointerEvent2 = PointerEvent::Create();
390 ASSERT_NE(pointerEvent2, nullptr);
391 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
392 pointerEvent2->SetPointerId(0);
393 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
394 pointerEvent2->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
395 ASSERT_TRUE(!pointerEvent2->IsValid());
396 }
397
398 /**
399 * @tc.name: PointerEventTest_CheckTouchPointEvent_002
400 * @tc.desc: Verify touch screen event
401 * @tc.type: FUNC
402 * @tc.require:
403 */
404 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_002, TestSize.Level1)
405 {
406 auto pointerEvent1 = PointerEvent::Create();
407 ASSERT_NE(pointerEvent1, nullptr);
408 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
409 pointerEvent1->SetPointerId(0);
410 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
411 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
412 PointerEvent::PointerItem item;
413 item.SetPointerId(-1);
414 pointerEvent1->AddPointerItem(item);
415 ASSERT_TRUE(!pointerEvent1->IsValid());
416
417 auto pointerEvent2 = PointerEvent::Create();
418 ASSERT_NE(pointerEvent2, nullptr);
419 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
420 pointerEvent2->SetPointerId(0);
421 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
422 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
423 item.SetPointerId(0);
424 item.SetDownTime(0);
425 item.SetPressed(false);
426 pointerEvent2->AddPointerItem(item);
427 ASSERT_TRUE(!pointerEvent2->IsValid());
428 }
429
430 /**
431 * @tc.name: PointerEventTest_CheckTouchPointEvent_003
432 * @tc.desc: Verify touch screen event
433 * @tc.type: FUNC
434 * @tc.require:
435 */
436 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_003, TestSize.Level1)
437 {
438 auto pointerEvent1 = PointerEvent::Create();
439 ASSERT_NE(pointerEvent1, nullptr);
440 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
441 pointerEvent1->SetPointerId(0);
442 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
443 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
444 PointerEvent::PointerItem item;
445 item.SetPointerId(0);
446 item.SetDownTime(100);
447 item.SetPressed(true);
448 pointerEvent1->AddPointerItem(item);
449 ASSERT_TRUE(!pointerEvent1->IsValid());
450
451 auto pointerEvent2 = PointerEvent::Create();
452 ASSERT_NE(pointerEvent2, nullptr);
453 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
454 pointerEvent2->SetPointerId(0);
455 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
456 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
457 PointerEvent::PointerItem item1;
458 item1.SetPointerId(0);
459 item1.SetDownTime(100);
460 item1.SetPressed(false);
461 pointerEvent2->AddPointerItem(item1);
462 PointerEvent::PointerItem item2;
463 item2.SetPointerId(0);
464 item2.SetDownTime(100);
465 item2.SetPressed(false);
466 pointerEvent2->AddPointerItem(item2);
467 ASSERT_TRUE(!pointerEvent2->IsValid());
468 }
469
470 /**
471 * @tc.name: PointerEventTest_CheckTouchPointEvent_004
472 * @tc.desc: Verify touch screen event
473 * @tc.type: FUNC
474 * @tc.require:
475 */
476 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_004, TestSize.Level1)
477 {
478 auto pointerEvent = PointerEvent::Create();
479 ASSERT_NE(pointerEvent, nullptr);
480 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
481 pointerEvent->SetPointerId(0);
482 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
483 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
484 PointerEvent::PointerItem item1;
485 item1.SetPointerId(1);
486 item1.SetDownTime(100);
487 item1.SetPressed(false);
488 pointerEvent->AddPointerItem(item1);
489 PointerEvent::PointerItem item2;
490 item2.SetPointerId(2);
491 item2.SetDownTime(100);
492 item2.SetPressed(false);
493 pointerEvent->AddPointerItem(item2);
494 ASSERT_TRUE(!pointerEvent->IsValid());
495 }
496
497 /**
498 * @tc.name: PointerEventTest_CheckTouchPointEvent_005
499 * @tc.desc: Verify touch screen event
500 * @tc.type: FUNC
501 * @tc.require:
502 */
503 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_005, TestSize.Level1)
504 {
505 auto pointerEvent = PointerEvent::Create();
506 ASSERT_NE(pointerEvent, nullptr);
507 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
508 pointerEvent->SetPointerId(0);
509 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
510 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
511 PointerEvent::PointerItem item1;
512 item1.SetPointerId(0);
513 item1.SetDownTime(100);
514 item1.SetPressed(false);
515 pointerEvent->AddPointerItem(item1);
516 PointerEvent::PointerItem item2;
517 item2.SetPointerId(1);
518 item2.SetDownTime(100);
519 item2.SetPressed(false);
520 pointerEvent->AddPointerItem(item2);
521 ASSERT_TRUE(pointerEvent->IsValid());
522 }
523
524 /**
525 * @tc.name: PointerEventTest_CheckTouchPointEvent_006
526 * @tc.desc: Verify touch screen event
527 * @tc.type: FUNC
528 * @tc.require: I5QSN3
529 */
530 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_006, TestSize.Level1)
531 {
532 auto pointerEvent = PointerEvent::Create();
533 ASSERT_NE(pointerEvent, nullptr);
534 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
535 pointerEvent->SetPointerId(0);
536 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
537 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
538 PointerEvent::PointerItem item;
539 item.SetPointerId(0);
540 item.SetDownTime(100);
541 item.SetToolDisplayX(90);
542 item.SetToolDisplayY(90);
543 item.SetToolWindowX(50);
544 item.SetToolWindowY(50);
545 item.SetToolWidth(30);
546 item.SetToolHeight(30);
547 item.SetLongAxis(100);
548 item.SetShortAxis(20);
549 item.SetToolType(2);
550 item.SetTargetWindowId(0);
551 pointerEvent->AddPointerItem(item);
552 ASSERT_TRUE(pointerEvent->IsValid());
553 DumpWindowData(pointerEvent);
554 pointerEvent->RemovePointerItem(0);
555 pointerEvent->IsButtonPressed(0);
556 pointerEvent->ClearButtonPressed();
557 pointerEvent->ClearAxisValue();
558 pointerEvent->DeleteReleaseButton(PointerEvent::BUTTON_NONE);
559 ASSERT_FALSE(pointerEvent->IsValid());
560 }
561
562 /**
563 * @tc.name: PointerEventTest_CheckTouchInputEvent_001
564 * @tc.desc: Verify touch screen event
565 * @tc.type: FUNC
566 * @tc.require: I5QSN3
567 */
568 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchInputEvent_001, TestSize.Level1)
569 {
570 auto inputEvent = InputEvent::Create();
571 ASSERT_NE(inputEvent, nullptr);
572 inputEvent->SetTargetDisplayId(0);
573 inputEvent->SetDeviceId(0);
574 inputEvent->EventTypeToString(InputEvent::EVENT_TYPE_POINTER);
575 inputEvent->HasFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
576 inputEvent->ClearFlag();
577 }
578 } // namespace MMI
579 } // namespace OHOS
580