1 /*
2 * Copyright (C) 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 <gtest/gtest.h>
17 #include "accessibility_common_helper.h"
18 #include "accessibility_element_operator_proxy.h"
19 #include "accessibility_touch_guider.h"
20 #include "accessibility_ut_helper.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Accessibility {
27 namespace {
28 constexpr uint32_t SLEEP_TIME_3 = 3;
29 constexpr int64_t MS_TO_US = 1000;
30 constexpr int32_t ACCOUNT_ID = 100;
31 constexpr int32_t WINDOW_ID = 2;
32 } // namespace
33
34 class TouchGuiderTest : public testing::Test {
35 public:
TouchGuiderTest()36 TouchGuiderTest()
37 {}
~TouchGuiderTest()38 ~TouchGuiderTest()
39 {}
40
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 bool TestEventType();
44 bool TestEventAction();
45 void SetUp() override;
46 void TearDown() override;
47
48 protected:
49 std::shared_ptr<MMI::PointerEvent> CreateTouchEvent(int32_t action);
50 std::shared_ptr<MMI::PointerEvent> CreateTouchEvent(int32_t action,
51 std::vector<MMI::PointerEvent::PointerItem> &points, int32_t pointerCount, int64_t occurredTime,
52 int64_t startTime);
53 std::shared_ptr<MMI::PointerEvent> CreateMoveEvent(int32_t pointerCount);
54 std::unique_ptr<TouchGuider> touchGuider_ = nullptr;
55 int32_t pointId_ = -1;
56 };
57
TestEventType()58 bool TouchGuiderTest::TestEventType()
59 {
60 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
61 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) ==
62 EventType::TYPE_TOUCH_BEGIN) {
63 return true;
64 } else {
65 return false;
66 }
67 }), SLEEP_TIME_3);
68 return ret;
69 }
70
TestEventAction()71 bool TouchGuiderTest::TestEventAction()
72 {
73 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
74 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
75 MMI::PointerEvent::POINTER_ACTION_DOWN) {
76 return true;
77 } else {
78 return false;
79 }
80 }), SLEEP_TIME_3);
81 return ret;
82 }
83
SetUpTestCase()84 void TouchGuiderTest::SetUpTestCase()
85 {
86 GTEST_LOG_(INFO) << "TouchGuiderTest SetUpTestCase";
87 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
88 }
89
TearDownTestCase()90 void TouchGuiderTest::TearDownTestCase()
91 {
92 GTEST_LOG_(INFO) << "TouchGuiderTest TearDownTestCase";
93 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
94 }
95
SetUp()96 void TouchGuiderTest::SetUp()
97 {
98 GTEST_LOG_(INFO) << "TouchGuiderTest SetUp";
99
100 touchGuider_ = std::make_unique<TouchGuider>();
101 if (!touchGuider_) {
102 GTEST_LOG_(INFO) << "touchGuider new failed!";
103 return;
104 }
105 touchGuider_->StartUp();
106 pointId_ = 0;
107 }
108
TearDown()109 void TouchGuiderTest::TearDown()
110 {
111 GTEST_LOG_(INFO) << "TouchGuiderTest TearDown";
112 AccessibilityAbilityHelper::GetInstance().ClearEventTypeActionVector();
113 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
114 }
115
CreateTouchEvent(int32_t action)116 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateTouchEvent(int32_t action)
117 {
118 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
119 MMI::PointerEvent::PointerItem item = {};
120
121 pointerEvent->AddPointerItem(item);
122 pointerEvent->SetPointerId(pointId_++);
123 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
124 pointerEvent->SetPointerAction(action);
125
126 return pointerEvent;
127 }
128
CreateTouchEvent(int32_t action,std::vector<MMI::PointerEvent::PointerItem> & points,int32_t pointerId,int64_t occurredTime,int64_t startTime)129 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateTouchEvent(int32_t action,
130 std::vector<MMI::PointerEvent::PointerItem> &points, int32_t pointerId, int64_t occurredTime,
131 int64_t startTime)
132 {
133 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
134
135 for (auto &point : points) {
136 pointerEvent->AddPointerItem(point);
137 }
138 pointerEvent->SetPointerId(pointerId);
139 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
140 pointerEvent->SetPointerAction(action);
141 pointerEvent->SetActionStartTime(startTime * MS_TO_US);
142 pointerEvent->SetActionTime(occurredTime * MS_TO_US);
143
144 return pointerEvent;
145 }
146
CreateMoveEvent(int32_t pointerCount)147 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateMoveEvent(int32_t pointerCount)
148 {
149 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
150 MMI::PointerEvent::PointerItem item = {};
151
152 pointerEvent->AddPointerItem(item);
153 pointerEvent->SetPointerId(pointId_++);
154 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
155 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
156
157 return pointerEvent;
158 }
159
160 /**
161 * @tc.number: OnPointerEvent001
162 * @tc.name: OnPointerEvent
163 * @tc.desc: Check the first down event.
164 */
165 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_001, TestSize.Level1)
166 {
167 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_001 start";
168 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
169 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0402() 170 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
171 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) == EventType::TYPE_TOUCH_BEGIN) {
172 return true;
173 } else {
174 return false;
175 }
176 }), SLEEP_TIME_3);
177 EXPECT_TRUE(ret);
178 }
179
180 /**
181 * @tc.number: OnPointerEvent002
182 * @tc.name: OnPointerEvent
183 * @tc.desc: Check the first up event.
184 */
185 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_002, TestSize.Level1)
186 {
187 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_002 start";
188 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
189 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0502() 190 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
191 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) == EventType::TYPE_TOUCH_BEGIN) {
192 return true;
193 } else {
194 return false;
195 }
196 }), SLEEP_TIME_3);
197 EXPECT_TRUE(ret);
198
199 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
200 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0602() 201 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
202 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) ==
203 EventType::TYPE_TOUCH_END) {
204 return true;
205 } else {
206 return false;
207 }
208 }), SLEEP_TIME_3);
209 EXPECT_TRUE(ret);
210 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
211 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_BEGIN);
212 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
213 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
214 EXPECT_EQ(touchAction, expectValue);
215 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
216 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_END);
217 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_002 end";
218 }
219
220 /**
221 * @tc.number: OnPointerEvent003
222 * @tc.name: OnPointerEvent
223 * @tc.desc: Check the event that down-up slowly.
224 */
225 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_003, TestSize.Level1)
226 {
227 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_003 start";
228
229 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
230 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0702() 231 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
232 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
233 EventType::TYPE_TOUCH_GUIDE_BEGIN) {
234 return true;
235 } else {
236 return false;
237 }
238 }), SLEEP_TIME_3);
239 EXPECT_TRUE(ret);
240 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
241 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
__anonf3154fba0802() 242 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
243 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
244 MMI::PointerEvent::POINTER_ACTION_MOVE) {
245 return true;
246 } else {
247 return false;
248 }
249 }), SLEEP_TIME_3);
250 EXPECT_TRUE(ret);
251
252 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
253 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0902() 254 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
255 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) ==
256 EventType::TYPE_TOUCH_END) {
257 return true;
258 } else {
259 return false;
260 }
261 }), SLEEP_TIME_3);
262 EXPECT_TRUE(ret);
263 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
264 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_END);
265
266 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_003 end";
267 }
268
269 /**
270 * @tc.number: OnPointerEvent004
271 * @tc.name: OnPointerEvent
272 * @tc.desc: Check the event that move slowly with one finger.
273 */
274 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_004, TestSize.Level1)
275 {
276 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_004 start";
277
278 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
279 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0a02() 280 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
281 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
282 EventType::TYPE_TOUCH_GUIDE_BEGIN) {
283 return true;
284 } else {
285 return false;
286 }
287 }), SLEEP_TIME_3);
288 EXPECT_TRUE(ret);
289 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
290 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
__anonf3154fba0b02() 291 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
292 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
293 MMI::PointerEvent::POINTER_ACTION_MOVE) {
294 return true;
295 } else {
296 return false;
297 }
298 }), SLEEP_TIME_3);
299 EXPECT_TRUE(ret);
300
301 event = CreateMoveEvent(1);
302 touchGuider_->OnPointerEvent(*event);
303 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
304 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_MOVE);
305
306 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
307 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0c02() 308 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
309 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == EventType::TYPE_TOUCH_END) {
310 return true;
311 } else {
312 return false;
313 }
314 }), SLEEP_TIME_3);
315 EXPECT_TRUE(ret);
316 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
317 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_END);
318
319 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_004 end";
320 }
321
322 /**
323 * @tc.number: OnPointerEvent005
324 * @tc.name: OnPointerEvent
325 * @tc.desc: Check the event that two fingers moving in same directions in touchGuiding state.
326 */
327 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_005, TestSize.Level1)
328 {
329 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_005 start";
330
331 std::vector<MMI::PointerEvent::PointerItem> points = {};
332 MMI::PointerEvent::PointerItem point = {};
333 point.SetPointerId(1);
334 MMI::PointerEvent::PointerItem otherPoint = {};
335 otherPoint.SetPointerId(2);
336 otherPoint.SetDisplayX(10);
337 otherPoint.SetDisplayY(10);
338
339 points.emplace_back(point);
340 std::shared_ptr<MMI::PointerEvent> event =
341 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
342 touchGuider_->OnPointerEvent(*event);
343 bool ret = TestEventType();
344 EXPECT_TRUE(ret);
345
346 points.emplace_back(otherPoint);
347 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
348 touchGuider_->OnPointerEvent(*event);
349 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
350 touchGuider_->OnPointerEvent(*event);
351 ret = TestEventAction();
352 EXPECT_TRUE(ret);
353
354 points.clear();
355 points.emplace_back(otherPoint);
356 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 2, 0, 0);
357 touchGuider_->OnPointerEvent(*event);
358 points.clear();
359 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
360 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0d02() 361 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
362 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
363 EventType::TYPE_TOUCH_END) {
364 return true;
365 } else {
366 return false;
367 }
368 }), SLEEP_TIME_3);
369 EXPECT_TRUE(ret);
370
371 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_005 end";
372 }
373
374 /**
375 * @tc.number: OnPointerEvent006
376 * @tc.name: OnPointerEvent
377 * @tc.desc: Check the event that multi-finger gesture.
378 */
379 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_006, TestSize.Level1)
380 {
381 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_006 start";
382
383 std::vector<MMI::PointerEvent::PointerItem> points = {};
384 MMI::PointerEvent::PointerItem point = {};
385 point.SetPointerId(1);
386 MMI::PointerEvent::PointerItem otherPoint = {};
387 otherPoint.SetPointerId(2);
388 otherPoint.SetDisplayX(10);
389 otherPoint.SetDisplayY(10);
390 MMI::PointerEvent::PointerItem otherPoint1 = {};
391 otherPoint1.SetPointerId(3);
392 otherPoint1.SetDisplayX(10);
393 otherPoint1.SetDisplayY(10);
394
395 points.emplace_back(point);
396 std::shared_ptr<MMI::PointerEvent> event =
397 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
398 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0e02() 399 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
400 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) ==
401 EventType::TYPE_TOUCH_BEGIN) {
402 return true;
403 } else {
404 return false;
405 }
406 }), SLEEP_TIME_3);
407 EXPECT_TRUE(ret);
408
409 points.emplace_back(otherPoint);
410 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
411 touchGuider_->OnPointerEvent(*event);
412
413 points.emplace_back(otherPoint1);
414 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 3, 0, 0);
415 touchGuider_->OnPointerEvent(*event);
416
417 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 3, 0, 0);
418 touchGuider_->OnPointerEvent(*event);
__anonf3154fba0f02() 419 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
420 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
421 MMI::PointerEvent::POINTER_ACTION_DOWN) {
422 return true;
423 } else {
424 return false;
425 }
426 }), SLEEP_TIME_3);
427 EXPECT_TRUE(ret);
428
429 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_006 end";
430 }
431
432 /**
433 * @tc.number: OnPointerEvent007
434 * @tc.name: OnPointerEvent
435 * @tc.desc: Check the CANCEL event.
436 */
437 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_007, TestSize.Level1)
438 {
439 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_007 start";
440
441 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
442 touchGuider_->OnPointerEvent(*event);
__anonf3154fba1002() 443 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
444 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
445 EventType::TYPE_TOUCH_GUIDE_BEGIN) {
446 return true;
447 } else {
448 return false;
449 }
450 }), SLEEP_TIME_3);
451 EXPECT_TRUE(ret);
452 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
453 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
454
__anonf3154fba1102() 455 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
456 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
457 MMI::PointerEvent::POINTER_ACTION_MOVE) {
458 return true;
459 } else {
460 return false;
461 }
462 }), SLEEP_TIME_3);
463 EXPECT_TRUE(ret);
464 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_CANCEL);
465 touchGuider_->OnPointerEvent(*event);
466
467 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_007 end";
468 }
469
470 /**
471 * @tc.number: OnPointerEvent008
472 * @tc.name: OnPointerEvent
473 * @tc.desc: Check the OTHER_POINT_DOWN event in draging state.
474 */
475 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_008, TestSize.Level1)
476 {
477 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_008 start";
478
479 std::vector<MMI::PointerEvent::PointerItem> points = {};
480 MMI::PointerEvent::PointerItem point = {};
481 point.SetPointerId(1);
482 MMI::PointerEvent::PointerItem otherPoint = {};
483 otherPoint.SetPointerId(2);
484 otherPoint.SetDisplayX(500);
485 otherPoint.SetDisplayY(500);
486 MMI::PointerEvent::PointerItem otherPoint1 = {};
487 otherPoint1.SetPointerId(3);
488 otherPoint1.SetDisplayX(500);
489 otherPoint1.SetDisplayY(500);
490
491 points.emplace_back(point);
492 std::shared_ptr<MMI::PointerEvent> event =
493 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
494 touchGuider_->OnPointerEvent(*event);
495
496 points.emplace_back(otherPoint);
497 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
498 touchGuider_->OnPointerEvent(*event);
499
500 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
501 touchGuider_->OnPointerEvent(*event);
502 bool ret = TestEventType();
503 EXPECT_TRUE(ret);
504 ret = TestEventAction();
505 EXPECT_TRUE(ret);
506
507 points.emplace_back(otherPoint1);
508 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 3, 0, 0);
509 touchGuider_->OnPointerEvent(*event);
__anonf3154fba1202() 510 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
511 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1) ==
512 MMI::PointerEvent::POINTER_ACTION_UP) {
513 return true;
514 } else {
515 return false;
516 }
517 }), SLEEP_TIME_3);
518 EXPECT_TRUE(ret);
519
520 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_008 end";
521 }
522
523 /**
524 * @tc.number: OnPointerEvent009
525 * @tc.name: OnPointerEvent
526 * @tc.desc: Check the event that two fingers moving in same directions in draging state.
527 */
528 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_009, TestSize.Level1)
529 {
530 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_009 start";
531
532 std::vector<MMI::PointerEvent::PointerItem> points = {};
533 MMI::PointerEvent::PointerItem point = {};
534 point.SetPointerId(1);
535 MMI::PointerEvent::PointerItem otherPoint = {};
536 otherPoint.SetPointerId(2);
537 otherPoint.SetDisplayX(10);
538 otherPoint.SetDisplayY(10);
539
540 points.emplace_back(point);
541 std::shared_ptr<MMI::PointerEvent> event =
542 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
543 touchGuider_->OnPointerEvent(*event);
__anonf3154fba1302() 544 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
545 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) ==
546 EventType::TYPE_TOUCH_BEGIN) {
547 return true;
548 } else {
549 return false;
550 }
551 }), SLEEP_TIME_3);
552 EXPECT_TRUE(ret);
553
554 points.emplace_back(otherPoint);
555 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
556 touchGuider_->OnPointerEvent(*event);
557 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
558 touchGuider_->OnPointerEvent(*event);
__anonf3154fba1402() 559 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
560 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
561 MMI::PointerEvent::POINTER_ACTION_DOWN) {
562 return true;
563 } else {
564 return false;
565 }
566 }), SLEEP_TIME_3);
567 EXPECT_TRUE(ret);
568
569 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
570 touchGuider_->OnPointerEvent(*event);
__anonf3154fba1502() 571 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
572 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1) ==
573 MMI::PointerEvent::POINTER_ACTION_MOVE) {
574 return true;
575 } else {
576 return false;
577 }
578 }), SLEEP_TIME_3);
579 EXPECT_TRUE(ret);
580
581 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_009 end";
582 }
583
584 /**
585 * @tc.number: OnPointerEvent010
586 * @tc.name: OnPointerEvent
587 * @tc.desc: Check the event that multi-finger moving in draging state.
588 */
589 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_010, TestSize.Level1)
590 {
591 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_010 start";
592
593 std::vector<MMI::PointerEvent::PointerItem> points = {};
594 MMI::PointerEvent::PointerItem point = {};
595 point.SetPointerId(1);
596 MMI::PointerEvent::PointerItem otherPoint = {};
597 otherPoint.SetPointerId(2);
598 otherPoint.SetDisplayX(500);
599 otherPoint.SetDisplayY(500);
600 MMI::PointerEvent::PointerItem otherPoint1 = {};
601 otherPoint1.SetPointerId(3);
602 otherPoint1.SetDisplayX(500);
603 otherPoint1.SetDisplayY(500);
604
605 points.emplace_back(point);
606 std::shared_ptr<MMI::PointerEvent> event =
607 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
608 touchGuider_->OnPointerEvent(*event);
__anonf3154fba1602() 609 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
610 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) ==
611 EventType::TYPE_TOUCH_BEGIN) {
612 return true;
613 } else {
614 return false;
615 }
616 }), SLEEP_TIME_3);
617 EXPECT_TRUE(ret);
618
619 points.emplace_back(otherPoint);
620 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
621 touchGuider_->OnPointerEvent(*event);
622 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
623 touchGuider_->OnPointerEvent(*event);
624 points.emplace_back(otherPoint1);
625 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 3, 0, 0);
626 touchGuider_->OnPointerEvent(*event);
__anonf3154fba1702() 627 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
628 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1) ==
629 MMI::PointerEvent::POINTER_ACTION_UP) {
630 return true;
631 } else {
632 return false;
633 }
634 }), SLEEP_TIME_3);
635 EXPECT_TRUE(ret);
636 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
637 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
638 EXPECT_EQ(touchAction, expectValue);
639
640 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_010 end";
641 }
642
643 /**
644 * @tc.number: OnPointerEvent012
645 * @tc.name: OnPointerEvent
646 * @tc.desc: Check cancel the second move event after onstart.
647 */
648 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_012, TestSize.Level1)
649 {
650 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_012 start";
651
652 std::vector<MMI::PointerEvent::PointerItem> points = {};
653 MMI::PointerEvent::PointerItem point = {};
654 point.SetPointerId(1);
655 point.SetDisplayX(500);
656 point.SetDisplayY(500);
657 MMI::PointerEvent::PointerItem movepoint = {};
658 movepoint.SetPointerId(1);
659 movepoint.SetDisplayX(2500);
660 movepoint.SetDisplayY(500);
661 MMI::PointerEvent::PointerItem othermovepoint = {};
662 othermovepoint.SetPointerId(1);
663 othermovepoint.SetDisplayX(2500);
664 othermovepoint.SetDisplayY(500);
665
666 points.emplace_back(point);
667 std::shared_ptr<MMI::PointerEvent> event =
668 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
669 touchGuider_->OnPointerEvent(*event);
670
671 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
672 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
673
674 points.clear();
675 points.emplace_back(movepoint);
676 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
677 touchGuider_->OnPointerEvent(*event);
678
679 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
680 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
681 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
682 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
683 EXPECT_EQ(touchAction, expectValue);
684
685 points.clear();
686 points.emplace_back(othermovepoint);
687 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 400, 0);
688 touchGuider_->OnPointerEvent(*event);
689 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
690 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
691
692 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_012 end";
693 }
694
695 /**
696 * @tc.number: OnPointerEvent013
697 * @tc.name: OnPointerEvent
698 * @tc.desc: Check the GESTURE_SWIPE_RIGHT_THEN_UP gesture.
699 */
700 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_013, TestSize.Level1)
701 {
702 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_013 start";
703
704 std::vector<MMI::PointerEvent::PointerItem> points = {};
705 MMI::PointerEvent::PointerItem point = {};
706 point.SetPointerId(1);
707 point.SetDisplayX(2500);
708 point.SetDisplayY(2500);
709 MMI::PointerEvent::PointerItem movepoint1 = {};
710 movepoint1.SetPointerId(1);
711 movepoint1.SetDisplayX(3500);
712 movepoint1.SetDisplayY(2500);
713 MMI::PointerEvent::PointerItem movepoint2 = {};
714 movepoint2.SetPointerId(1);
715 movepoint2.SetDisplayX(5000);
716 movepoint2.SetDisplayY(2500);
717 MMI::PointerEvent::PointerItem movepoint3 = {};
718 movepoint3.SetPointerId(1);
719 movepoint3.SetDisplayX(4000);
720 movepoint3.SetDisplayY(0);
721
722 points.emplace_back(point);
723 std::shared_ptr<MMI::PointerEvent> event =
724 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
725 touchGuider_->OnPointerEvent(*event);
726
727 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
728 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
729
730 points.clear();
731 points.emplace_back(movepoint1);
732 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
733 touchGuider_->OnPointerEvent(*event);
734
735 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
736 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
737 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
738 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
739 EXPECT_EQ(touchAction, expectValue);
740
741 points.clear();
742 points.emplace_back(movepoint2);
743 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
744 touchGuider_->OnPointerEvent(*event);
745
746 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
747 EXPECT_EQ(touchAction, expectValue);
748
749 points.clear();
750 points.emplace_back(movepoint3);
751 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
752 touchGuider_->OnPointerEvent(*event);
753
754 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2);
755 EXPECT_EQ(touchAction, expectValue);
756
757 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
758 touchGuider_->OnPointerEvent(*event);
759
760 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
761 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
762 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3);
763 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_END);
764 auto uTgestureId = AccessibilityAbilityHelper::GetInstance().GetGestureId();
765 EXPECT_EQ(uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_RIGHT_THEN_UP));
766
767 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_013 end";
768 }
769
770 /**
771 * @tc.number: OnPointerEvent014
772 * @tc.name: OnPointerEvent
773 * @tc.desc: Check the GESTURE_SWIPE_LEFT_THEN_UP gesture.
774 */
775 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_014, TestSize.Level1)
776 {
777 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_014 start";
778
779 std::vector<MMI::PointerEvent::PointerItem> points = {};
780 MMI::PointerEvent::PointerItem point = {};
781 point.SetPointerId(1);
782 point.SetDisplayX(2500);
783 point.SetDisplayY(2500);
784 MMI::PointerEvent::PointerItem movepoint1 = {};
785 movepoint1.SetPointerId(1);
786 movepoint1.SetDisplayX(1500);
787 movepoint1.SetDisplayY(2500);
788 MMI::PointerEvent::PointerItem movepoint2 = {};
789 movepoint2.SetPointerId(1);
790 movepoint2.SetDisplayX(0);
791 movepoint2.SetDisplayY(2500);
792 MMI::PointerEvent::PointerItem movepoint3 = {};
793 movepoint3.SetPointerId(1);
794 movepoint3.SetDisplayX(1000);
795 movepoint3.SetDisplayY(0);
796
797 points.emplace_back(point);
798 std::shared_ptr<MMI::PointerEvent> event =
799 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
800 touchGuider_->OnPointerEvent(*event);
801
802 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
803 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
804
805 points.clear();
806 points.emplace_back(movepoint1);
807 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
808 touchGuider_->OnPointerEvent(*event);
809
810 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
811 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
812 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
813 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
814 EXPECT_EQ(touchAction, expectValue);
815
816 points.clear();
817 points.emplace_back(movepoint2);
818 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
819 touchGuider_->OnPointerEvent(*event);
820
821 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
822 EXPECT_EQ(touchAction, expectValue);
823
824 points.clear();
825 points.emplace_back(movepoint3);
826 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
827 touchGuider_->OnPointerEvent(*event);
828
829 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2);
830 EXPECT_EQ(touchAction, expectValue);
831
832 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
833 touchGuider_->OnPointerEvent(*event);
834
835 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
836 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
837 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3);
838 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_END);
839 auto uTgestureId = AccessibilityAbilityHelper::GetInstance().GetGestureId();
840 EXPECT_EQ(uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_LEFT_THEN_UP));
841
842 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_014 end";
843 }
844
845 /**
846 * @tc.number: OnPointerEvent015
847 * @tc.name: OnPointerEvent
848 * @tc.desc: Check the GESTURE_SWIPE_DOWN_THEN_LEFT gesture.
849 */
850 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_015, TestSize.Level1)
851 {
852 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_015 start";
853
854 std::vector<MMI::PointerEvent::PointerItem> points = {};
855 MMI::PointerEvent::PointerItem point = {};
856 point.SetPointerId(1);
857 point.SetDisplayX(2500);
858 point.SetDisplayY(2500);
859 MMI::PointerEvent::PointerItem movepoint1 = {};
860 movepoint1.SetPointerId(1);
861 movepoint1.SetDisplayX(2500);
862 movepoint1.SetDisplayY(3500);
863 MMI::PointerEvent::PointerItem movepoint2 = {};
864 movepoint2.SetPointerId(1);
865 movepoint2.SetDisplayX(2500);
866 movepoint2.SetDisplayY(5000);
867 MMI::PointerEvent::PointerItem movepoint3 = {};
868 movepoint3.SetPointerId(1);
869 movepoint3.SetDisplayX(0);
870 movepoint3.SetDisplayY(4000);
871
872 points.emplace_back(point);
873 std::shared_ptr<MMI::PointerEvent> event =
874 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
875 touchGuider_->OnPointerEvent(*event);
876
877 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
878 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
879
880 points.clear();
881 points.emplace_back(movepoint1);
882 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
883 touchGuider_->OnPointerEvent(*event);
884
885 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
886 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
887 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
888 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
889 EXPECT_EQ(touchAction, expectValue);
890
891 points.clear();
892 points.emplace_back(movepoint2);
893 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
894 touchGuider_->OnPointerEvent(*event);
895
896 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
897 EXPECT_EQ(touchAction, expectValue);
898
899 points.clear();
900 points.emplace_back(movepoint3);
901 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
902 touchGuider_->OnPointerEvent(*event);
903
904 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2);
905 EXPECT_EQ(touchAction, expectValue);
906
907 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
908 touchGuider_->OnPointerEvent(*event);
909
910 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
911 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
912 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3);
913 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_END);
914 auto uTgestureId = AccessibilityAbilityHelper::GetInstance().GetGestureId();
915 EXPECT_EQ(uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_DOWN_THEN_LEFT));
916
917 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_015 end";
918 }
919
920 /**
921 * @tc.number: OnPointerEvent016
922 * @tc.name: OnPointerEvent
923 * @tc.desc: Check the GESTURE_SWIPE_DOWN_THEN_RIGHT gesture.
924 */
925 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_016, TestSize.Level1)
926 {
927 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_016 start";
928
929 std::vector<MMI::PointerEvent::PointerItem> points = {};
930 MMI::PointerEvent::PointerItem point = {};
931 point.SetPointerId(1);
932 point.SetDisplayX(2500);
933 point.SetDisplayY(2500);
934 MMI::PointerEvent::PointerItem movepoint1 = {};
935 movepoint1.SetPointerId(1);
936 movepoint1.SetDisplayX(2500);
937 movepoint1.SetDisplayY(3500);
938 MMI::PointerEvent::PointerItem movepoint2 = {};
939 movepoint2.SetPointerId(1);
940 movepoint2.SetDisplayX(2500);
941 movepoint2.SetDisplayY(5000);
942 MMI::PointerEvent::PointerItem movepoint3 = {};
943 movepoint3.SetPointerId(1);
944 movepoint3.SetDisplayX(5000);
945 movepoint3.SetDisplayY(4000);
946
947 points.emplace_back(point);
948 std::shared_ptr<MMI::PointerEvent> event =
949 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
950 touchGuider_->OnPointerEvent(*event);
951
952 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
953 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
954
955 points.clear();
956 points.emplace_back(movepoint1);
957 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
958 touchGuider_->OnPointerEvent(*event);
959
960 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
961 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
962 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
963 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
964 EXPECT_EQ(touchAction, expectValue);
965
966 points.clear();
967 points.emplace_back(movepoint2);
968 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
969 touchGuider_->OnPointerEvent(*event);
970
971 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
972 EXPECT_EQ(touchAction, expectValue);
973
974 points.clear();
975 points.emplace_back(movepoint3);
976 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
977 touchGuider_->OnPointerEvent(*event);
978
979 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2);
980 EXPECT_EQ(touchAction, expectValue);
981
982 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
983 touchGuider_->OnPointerEvent(*event);
984
985 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
986 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
987 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3);
988 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_END);
989 auto uTgestureId = AccessibilityAbilityHelper::GetInstance().GetGestureId();
990 EXPECT_EQ(uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_DOWN_THEN_RIGHT));
991
992 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_016 end";
993 }
994
995 /**
996 * @tc.number: OnPointerEvent017
997 * @tc.name: OnPointerEvent
998 * @tc.desc: Check the LEFT gesture.
999 */
1000 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_017, TestSize.Level1)
1001 {
1002 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_017 start";
1003
1004 std::vector<MMI::PointerEvent::PointerItem> points = {};
1005 MMI::PointerEvent::PointerItem point = {};
1006 point.SetPointerId(1);
1007 point.SetDisplayX(2500);
1008 point.SetDisplayY(2500);
1009 MMI::PointerEvent::PointerItem movepoint1 = {};
1010 movepoint1.SetPointerId(1);
1011 movepoint1.SetDisplayX(1000);
1012 movepoint1.SetDisplayY(2500);
1013 MMI::PointerEvent::PointerItem movepoint2 = {};
1014 movepoint2.SetPointerId(1);
1015 movepoint2.SetDisplayX(0);
1016 movepoint2.SetDisplayY(2500);
1017
1018 points.emplace_back(point);
1019 std::shared_ptr<MMI::PointerEvent> event =
1020 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
1021 touchGuider_->OnPointerEvent(*event);
1022
1023 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
1024 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
1025
1026 points.clear();
1027 points.emplace_back(movepoint1);
1028 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
1029 touchGuider_->OnPointerEvent(*event);
1030
1031 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
1032 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
1033 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
1034 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
1035 EXPECT_EQ(touchAction, expectValue);
1036
1037 points.clear();
1038 points.emplace_back(movepoint2);
1039 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
1040 touchGuider_->OnPointerEvent(*event);
1041
1042 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
1043 EXPECT_EQ(touchAction, expectValue);
1044
1045 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
1046 touchGuider_->OnPointerEvent(*event);
1047
1048 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
1049 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
1050 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3);
1051 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_END);
1052 auto uTgestureId = AccessibilityAbilityHelper::GetInstance().GetGestureId();
1053 EXPECT_EQ(uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_LEFT));
1054
1055 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_017 end";
1056 }
1057
1058 /**
1059 * @tc.number: OnPointerEvent018
1060 * @tc.name: OnPointerEvent
1061 * @tc.desc: Check the DoubleTap gesture.
1062 */
1063 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_018, TestSize.Level1)
1064 {
1065 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_018 start";
1066
1067 if (!touchGuider_) {
1068 GTEST_LOG_(INFO) << "touchGuider_ is null";
1069 return;
1070 }
1071
1072 sptr<AccessibilityAccountData> accountData =
1073 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1074 if (!accountData) {
1075 GTEST_LOG_(INFO) << "accountData is null";
1076 return;
1077 }
1078
1079 AccessibilityAbilityHelper::GetInstance().SetRealId(WINDOW_ID);
1080 sptr<IAccessibilityElementOperator> proxy = new(std::nothrow) AccessibilityElementOperatorProxy(nullptr);
1081 sptr<AccessibilityWindowConnection> windowConnection =
1082 new(std::nothrow) AccessibilityWindowConnection(WINDOW_ID, proxy, ACCOUNT_ID);
1083 accountData->AddAccessibilityWindowConnection(WINDOW_ID, windowConnection);
1084
1085 // send down event
1086 std::vector<MMI::PointerEvent::PointerItem> points = {};
1087 MMI::PointerEvent::PointerItem point = {};
1088 point.SetPointerId(1);
1089 point.SetDisplayX(2500);
1090 point.SetDisplayY(2500);
1091 points.emplace_back(point);
1092 std::shared_ptr<MMI::PointerEvent> event =
1093 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
1094 touchGuider_->OnPointerEvent(*event);
1095
1096 // send up event
1097 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
1098 touchGuider_->OnPointerEvent(*event);
1099
1100 // send down event
1101 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 200, 200);
1102 touchGuider_->OnPointerEvent(*event);
1103
1104 // send up event
1105 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 200, 200);
1106 touchGuider_->OnPointerEvent(*event);
__anonf3154fba1802() 1107 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1108 if (AccessibilityAbilityHelper::GetInstance().GetExecuteAction() == ACCESSIBILITY_ACTION_CLICK) {
1109 return true;
1110 } else {
1111 return false;
1112 }
1113 }), SLEEP_TIME_3);
1114 EXPECT_TRUE(ret);
1115
1116 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_018 end";
1117 }
1118
1119 /**
1120 * @tc.number: DestroyEvents
1121 * @tc.name: DestroyEvents
1122 * @tc.desc: Check DestroyEvents.
1123 */
1124 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_DestroyEvents_001, TestSize.Level1)
1125 {
1126 GTEST_LOG_(INFO) << "TouchGuider_Unittest_DestroyEvents_001 start";
1127
1128 touchGuider_->DestroyEvents();
1129 bool isDestroyEvents;
1130 isDestroyEvents = AccessibilityAbilityHelper::GetInstance().GetDestroyState();
1131 EXPECT_EQ(isDestroyEvents, true);
1132
1133 GTEST_LOG_(INFO) << "TouchGuider_Unittest_DestroyEvents_001 end";
1134 }
1135 } // namespace Accessibility
1136 } // namespace OHOS