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