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