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 void SetUp() override;
44 void TearDown() override;
45
46 protected:
47 std::shared_ptr<MMI::PointerEvent> CreateTouchEvent(int32_t action);
48 std::shared_ptr<MMI::PointerEvent> CreateTouchEvent(int32_t action,
49 std::vector<MMI::PointerEvent::PointerItem> &points, int32_t pointerCount, int64_t occurredTime,
50 int64_t startTime);
51 std::shared_ptr<MMI::PointerEvent> CreateMoveEvent(int32_t pointerCount);
52 std::unique_ptr<TouchGuider> touchGuider_ = nullptr;
53 int32_t pointId_ = -1;
54 };
55
SetUpTestCase()56 void TouchGuiderTest::SetUpTestCase()
57 {
58 GTEST_LOG_(INFO) << "TouchGuiderTest SetUpTestCase";
59 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
60 }
61
TearDownTestCase()62 void TouchGuiderTest::TearDownTestCase()
63 {
64 GTEST_LOG_(INFO) << "TouchGuiderTest TearDownTestCase";
65 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
66 }
67
SetUp()68 void TouchGuiderTest::SetUp()
69 {
70 GTEST_LOG_(INFO) << "TouchGuiderTest SetUp";
71
72 touchGuider_ = std::make_unique<TouchGuider>();
73 if (!touchGuider_) {
74 GTEST_LOG_(INFO) << "touchGuider new failed!";
75 return;
76 }
77 touchGuider_->StartUp();
78 pointId_ = 0;
79 }
80
TearDown()81 void TouchGuiderTest::TearDown()
82 {
83 GTEST_LOG_(INFO) << "TouchGuiderTest TearDown";
84 AccessibilityAbilityHelper::GetInstance().ClearEventTypeActionVector();
85 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
86 }
87
CreateTouchEvent(int32_t action)88 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateTouchEvent(int32_t action)
89 {
90 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
91 MMI::PointerEvent::PointerItem item = {};
92
93 pointerEvent->AddPointerItem(item);
94 pointerEvent->SetPointerId(pointId_++);
95 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
96 pointerEvent->SetPointerAction(action);
97
98 return pointerEvent;
99 }
100
CreateTouchEvent(int32_t action,std::vector<MMI::PointerEvent::PointerItem> & points,int32_t pointerId,int64_t occurredTime,int64_t startTime)101 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateTouchEvent(int32_t action,
102 std::vector<MMI::PointerEvent::PointerItem> &points, int32_t pointerId, int64_t occurredTime,
103 int64_t startTime)
104 {
105 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
106
107 for (auto &point : points) {
108 pointerEvent->AddPointerItem(point);
109 }
110 pointerEvent->SetPointerId(pointerId);
111 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
112 pointerEvent->SetPointerAction(action);
113 pointerEvent->SetActionStartTime(startTime * MS_TO_US);
114 pointerEvent->SetActionTime(occurredTime * MS_TO_US);
115
116 return pointerEvent;
117 }
118
CreateMoveEvent(int32_t pointerCount)119 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateMoveEvent(int32_t pointerCount)
120 {
121 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
122 MMI::PointerEvent::PointerItem item = {};
123
124 pointerEvent->AddPointerItem(item);
125 pointerEvent->SetPointerId(pointId_++);
126 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
127 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
128
129 return pointerEvent;
130 }
131
132 /**
133 * @tc.number: OnPointerEvent001
134 * @tc.name: OnPointerEvent
135 * @tc.desc: Check the first down event.
136 */
137 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_001, TestSize.Level1)
138 {
139 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_001 start";
140 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
141 touchGuider_->OnPointerEvent(*event);
__anon43824a190202() 142 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
143 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) == EventType::TYPE_TOUCH_BEGIN) {
144 return true;
145 } else {
146 return false;
147 }
148 }), SLEEP_TIME_3);
149 EXPECT_TRUE(ret);
150 }
151
152 /**
153 * @tc.number: OnPointerEvent002
154 * @tc.name: OnPointerEvent
155 * @tc.desc: Check the first up event.
156 */
157 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_002, TestSize.Level1)
158 {
159 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_002 start";
160 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
161 touchGuider_->OnPointerEvent(*event);
__anon43824a190302() 162 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
163 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) == EventType::TYPE_TOUCH_BEGIN) {
164 return true;
165 } else {
166 return false;
167 }
168 }), SLEEP_TIME_3);
169 EXPECT_TRUE(ret);
170
171 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
172 touchGuider_->OnPointerEvent(*event);
__anon43824a190402() 173 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
174 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) ==
175 EventType::TYPE_TOUCH_END) {
176 return true;
177 } else {
178 return false;
179 }
180 }), SLEEP_TIME_3);
181 EXPECT_TRUE(ret);
182 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
183 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_BEGIN);
184 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
185 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
186 EXPECT_EQ(touchAction, expectValue);
187 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
188 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_END);
189 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_002 end";
190 }
191
192 /**
193 * @tc.number: OnPointerEvent003
194 * @tc.name: OnPointerEvent
195 * @tc.desc: Check the event that down-up slowly.
196 */
197 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_003, TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_003 start";
200
201 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
202 touchGuider_->OnPointerEvent(*event);
__anon43824a190502() 203 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
204 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
205 EventType::TYPE_TOUCH_GUIDE_BEGIN) {
206 return true;
207 } else {
208 return false;
209 }
210 }), SLEEP_TIME_3);
211 EXPECT_TRUE(ret);
212 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
213 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
__anon43824a190602() 214 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
215 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
216 MMI::PointerEvent::POINTER_ACTION_MOVE) {
217 return true;
218 } else {
219 return false;
220 }
221 }), SLEEP_TIME_3);
222 EXPECT_TRUE(ret);
223
224 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
225 touchGuider_->OnPointerEvent(*event);
__anon43824a190702() 226 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
227 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) ==
228 EventType::TYPE_TOUCH_END) {
229 return true;
230 } else {
231 return false;
232 }
233 }), SLEEP_TIME_3);
234 EXPECT_TRUE(ret);
235 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
236 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_END);
237
238 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_003 end";
239 }
240
241 /**
242 * @tc.number: OnPointerEvent004
243 * @tc.name: OnPointerEvent
244 * @tc.desc: Check the event that move slowly with one finger.
245 */
246 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_004, TestSize.Level1)
247 {
248 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_004 start";
249
250 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
251 touchGuider_->OnPointerEvent(*event);
__anon43824a190802() 252 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
253 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
254 EventType::TYPE_TOUCH_GUIDE_BEGIN) {
255 return true;
256 } else {
257 return false;
258 }
259 }), SLEEP_TIME_3);
260 EXPECT_TRUE(ret);
261 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
262 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
__anon43824a190902() 263 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
264 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
265 MMI::PointerEvent::POINTER_ACTION_MOVE) {
266 return true;
267 } else {
268 return false;
269 }
270 }), SLEEP_TIME_3);
271 EXPECT_TRUE(ret);
272
273 event = CreateMoveEvent(1);
274 touchGuider_->OnPointerEvent(*event);
275 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
276 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_MOVE);
277
278 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
279 touchGuider_->OnPointerEvent(*event);
__anon43824a190a02() 280 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
281 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == EventType::TYPE_TOUCH_END) {
282 return true;
283 } else {
284 return false;
285 }
286 }), SLEEP_TIME_3);
287 EXPECT_TRUE(ret);
288 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
289 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_END);
290
291 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_004 end";
292 }
293
294 /**
295 * @tc.number: OnPointerEvent005
296 * @tc.name: OnPointerEvent
297 * @tc.desc: Check the event that two fingers moving in same directions in touchGuiding state.
298 */
299 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_005, TestSize.Level1)
300 {
301 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_005 start";
302
303 std::vector<MMI::PointerEvent::PointerItem> points = {};
304 MMI::PointerEvent::PointerItem point = {};
305 point.SetPointerId(1);
306 MMI::PointerEvent::PointerItem otherPoint = {};
307 otherPoint.SetPointerId(2);
308 otherPoint.SetDisplayX(10);
309 otherPoint.SetDisplayY(10);
310
311 points.emplace_back(point);
312 std::shared_ptr<MMI::PointerEvent> event =
313 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
314 touchGuider_->OnPointerEvent(*event);
__anon43824a190b02() 315 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
316 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) ==
317 EventType::TYPE_TOUCH_BEGIN) {
318 return true;
319 } else {
320 return false;
321 }
322 }), SLEEP_TIME_3);
323 EXPECT_TRUE(ret);
324
325 points.emplace_back(otherPoint);
326 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
327 touchGuider_->OnPointerEvent(*event);
328 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
329 touchGuider_->OnPointerEvent(*event);
__anon43824a190c02() 330 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
331 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
332 MMI::PointerEvent::POINTER_ACTION_DOWN) {
333 return true;
334 } else {
335 return false;
336 }
337 }), SLEEP_TIME_3);
338 EXPECT_TRUE(ret);
339
340 points.clear();
341 points.emplace_back(otherPoint);
342 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 2, 0, 0);
343 touchGuider_->OnPointerEvent(*event);
344 points.clear();
345 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
346 touchGuider_->OnPointerEvent(*event);
__anon43824a190d02() 347 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
348 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
349 EventType::TYPE_TOUCH_END) {
350 return true;
351 } else {
352 return false;
353 }
354 }), SLEEP_TIME_3);
355 EXPECT_TRUE(ret);
356
357 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_005 end";
358 }
359
360 /**
361 * @tc.number: OnPointerEvent006
362 * @tc.name: OnPointerEvent
363 * @tc.desc: Check the event that multi-finger gesture.
364 */
365 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_006, TestSize.Level1)
366 {
367 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_006 start";
368
369 std::vector<MMI::PointerEvent::PointerItem> points = {};
370 MMI::PointerEvent::PointerItem point = {};
371 point.SetPointerId(1);
372 MMI::PointerEvent::PointerItem otherPoint = {};
373 otherPoint.SetPointerId(2);
374 otherPoint.SetDisplayX(10);
375 otherPoint.SetDisplayY(10);
376 MMI::PointerEvent::PointerItem otherPoint1 = {};
377 otherPoint1.SetPointerId(3);
378 otherPoint1.SetDisplayX(10);
379 otherPoint1.SetDisplayY(10);
380
381 points.emplace_back(point);
382 std::shared_ptr<MMI::PointerEvent> event =
383 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
384 touchGuider_->OnPointerEvent(*event);
__anon43824a190e02() 385 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
386 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) ==
387 EventType::TYPE_TOUCH_BEGIN) {
388 return true;
389 } else {
390 return false;
391 }
392 }), SLEEP_TIME_3);
393 EXPECT_TRUE(ret);
394
395 points.emplace_back(otherPoint);
396 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
397 touchGuider_->OnPointerEvent(*event);
398
399 points.emplace_back(otherPoint1);
400 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 3, 0, 0);
401 touchGuider_->OnPointerEvent(*event);
402
403 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 3, 0, 0);
404 touchGuider_->OnPointerEvent(*event);
__anon43824a190f02() 405 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
406 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
407 MMI::PointerEvent::POINTER_ACTION_DOWN) {
408 return true;
409 } else {
410 return false;
411 }
412 }), SLEEP_TIME_3);
413 EXPECT_TRUE(ret);
414
415 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_006 end";
416 }
417
418 /**
419 * @tc.number: OnPointerEvent007
420 * @tc.name: OnPointerEvent
421 * @tc.desc: Check the CANCEL event.
422 */
423 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_007, TestSize.Level1)
424 {
425 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_007 start";
426
427 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
428 touchGuider_->OnPointerEvent(*event);
__anon43824a191002() 429 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
430 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
431 EventType::TYPE_TOUCH_GUIDE_BEGIN) {
432 return true;
433 } else {
434 return false;
435 }
436 }), SLEEP_TIME_3);
437 EXPECT_TRUE(ret);
438 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
439 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
440
__anon43824a191102() 441 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
442 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
443 MMI::PointerEvent::POINTER_ACTION_MOVE) {
444 return true;
445 } else {
446 return false;
447 }
448 }), SLEEP_TIME_3);
449 EXPECT_TRUE(ret);
450 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_CANCEL);
451 touchGuider_->OnPointerEvent(*event);
452
453 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_007 end";
454 }
455
456 /**
457 * @tc.number: OnPointerEvent008
458 * @tc.name: OnPointerEvent
459 * @tc.desc: Check the OTHER_POINT_DOWN event in draging state.
460 */
461 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_008, TestSize.Level1)
462 {
463 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_008 start";
464
465 std::vector<MMI::PointerEvent::PointerItem> points = {};
466 MMI::PointerEvent::PointerItem point = {};
467 point.SetPointerId(1);
468 MMI::PointerEvent::PointerItem otherPoint = {};
469 otherPoint.SetPointerId(2);
470 otherPoint.SetDisplayX(500);
471 otherPoint.SetDisplayY(500);
472 MMI::PointerEvent::PointerItem otherPoint1 = {};
473 otherPoint1.SetPointerId(3);
474 otherPoint1.SetDisplayX(500);
475 otherPoint1.SetDisplayY(500);
476
477 points.emplace_back(point);
478 std::shared_ptr<MMI::PointerEvent> event =
479 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
480 touchGuider_->OnPointerEvent(*event);
481
482 points.emplace_back(otherPoint);
483 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
484 touchGuider_->OnPointerEvent(*event);
485
486 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
487 touchGuider_->OnPointerEvent(*event);
__anon43824a191202() 488 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
489 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) ==
490 EventType::TYPE_TOUCH_BEGIN) {
491 return true;
492 } else {
493 return false;
494 }
495 }), SLEEP_TIME_3);
496 EXPECT_TRUE(ret);
__anon43824a191302() 497 ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
498 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
499 MMI::PointerEvent::POINTER_ACTION_DOWN) {
500 return true;
501 } else {
502 return false;
503 }
504 }), SLEEP_TIME_3);
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);
__anon43824a191402() 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);
__anon43824a191502() 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);
__anon43824a191602() 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);
__anon43824a191702() 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);
__anon43824a191802() 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);
__anon43824a191902() 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);
__anon43824a191a02() 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