1 /*
2 * Copyright (C) 2024 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_exploration.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 int32_t POINT_ID_0 = 0;
29 constexpr int32_t POINT_ID_1 = 1;
30 constexpr int32_t POINT_ID_2 = 2;
31 constexpr int32_t POINT_ID_3 = 3;
32 constexpr int32_t SLEEP_US_50 = 50;
33 constexpr int32_t SLEEP_US_300 = 300;
34 constexpr int32_t ACTION_INVALID = -1;
35 constexpr int32_t DISPLAY_10 = 10;
36 constexpr int32_t DISPLAY_500 = 500;
37 constexpr int32_t DISPLAY_1000 = 1000;
38 constexpr int32_t DISPLAY_1500 = 1500;
39 } // namespace
40
41 class TouchExplorationTest : public testing::Test {
42 public:
TouchExplorationTest()43 TouchExplorationTest()
44 {}
~TouchExplorationTest()45 ~TouchExplorationTest()
46 {}
47
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 static void SetTouchExplorationPoint(MMI::PointerEvent::PointerItem &point, int id, int x, int y);
51 void SetUp() override;
52 void TearDown() override;
53
54 protected:
55 std::shared_ptr<MMI::PointerEvent> CreateTouchEvent(int32_t action, int32_t pointerId, int32_t displayX,
56 int32_t displayY);
57 std::shared_ptr<MMI::PointerEvent> CreateTouchEvent(int32_t action,
58 std::vector<MMI::PointerEvent::PointerItem> &points, int32_t pointerCount);
59 std::unique_ptr<TouchExploration> touchExploration_ = nullptr;
60 };
61
SetTouchExplorationPoint(MMI::PointerEvent::PointerItem & point,int id,int x,int y)62 void TouchExplorationTest::SetTouchExplorationPoint(MMI::PointerEvent::PointerItem &point, int id, int x, int y)
63 {
64 point.SetPointerId(id);
65 point.SetDisplayX(x);
66 point.SetDisplayY(y);
67 }
68
SetUpTestCase()69 void TouchExplorationTest::SetUpTestCase()
70 {
71 GTEST_LOG_(INFO) << "TouchExplorationTest SetUpTestCase";
72 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
73 }
74
TearDownTestCase()75 void TouchExplorationTest::TearDownTestCase()
76 {
77 GTEST_LOG_(INFO) << "TouchExplorationTest TearDownTestCase";
78 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
79 }
80
SetUp()81 void TouchExplorationTest::SetUp()
82 {
83 GTEST_LOG_(INFO) << "TouchExplorationTest SetUp";
84
85 touchExploration_ = std::make_unique<TouchExploration>();
86 if (!touchExploration_) {
87 GTEST_LOG_(INFO) << "TouchExploration new failed!";
88 return;
89 }
90 touchExploration_->StartUp();
91 }
92
TearDown()93 void TouchExplorationTest::TearDown()
94 {
95 GTEST_LOG_(INFO) << "TouchExplorationTest TearDown";
96 AccessibilityAbilityHelper::GetInstance().ClearEventTypeActionVector();
97 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
98 usleep(SLEEP_US_300);
99 touchExploration_->Clear();
100 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
101 }
102
CreateTouchEvent(int32_t action,int32_t pointerId,int32_t displayX,int32_t displayY)103 std::shared_ptr<MMI::PointerEvent> TouchExplorationTest::CreateTouchEvent(int32_t action, int32_t pointerId,
104 int32_t displayX, int32_t displayY)
105 {
106 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
107 MMI::PointerEvent::PointerItem item = {};
108
109 item.SetPointerId(pointerId);
110 item.SetDisplayX(displayX);
111 item.SetDisplayY(displayY);
112 item.SetPressed(action == MMI::PointerEvent::POINTER_ACTION_UP ? false : true);
113 pointerEvent->AddPointerItem(item);
114 pointerEvent->SetPointerId(pointerId);
115 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
116 pointerEvent->SetPointerAction(action);
117
118 return pointerEvent;
119 }
120
CreateTouchEvent(int32_t action,std::vector<MMI::PointerEvent::PointerItem> & points,int32_t pointerId)121 std::shared_ptr<MMI::PointerEvent> TouchExplorationTest::CreateTouchEvent(int32_t action,
122 std::vector<MMI::PointerEvent::PointerItem> &points, int32_t pointerId)
123 {
124 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
125
126 for (auto &point : points) {
127 if (point.GetPointerId() == pointerId) {
128 point.SetPressed(action == MMI::PointerEvent::POINTER_ACTION_UP ? false : true);
129 } else {
130 point.SetPressed(true);
131 }
132 pointerEvent->AddPointerItem(point);
133 }
134 pointerEvent->SetPointerId(pointerId);
135 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
136 pointerEvent->SetPointerAction(action);
137
138 return pointerEvent;
139 }
140
141 /**
142 * @tc.number: HandleInitStateDown001
143 * @tc.name: HandleInitStateDown
144 * @tc.desc: Test func HandleInitStateDown.
145 */
146 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleInitStateDown_001, TestSize.Level0)
147 {
148 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateDown_001 start";
149
150 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
151
152 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
153 0, 0);
154 touchExploration_->OnPointerEvent(*event);
155
156 usleep(SLEEP_US_50);
157
158 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_DOWN);
159
160 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateDown_001 end";
161 }
162
163 /**
164 * @tc.number: HandleInitStateDown002
165 * @tc.name: HandleInitStateDown
166 * @tc.desc: Test func HandleInitStateDown.
167 */
168 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleInitStateDown_002, TestSize.Level0)
169 {
170 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateDown_002 start";
171
172 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
173
174 std::vector<MMI::PointerEvent::PointerItem> points = {};
175 MMI::PointerEvent::PointerItem point = {};
176 SetTouchExplorationPoint(point, POINT_ID_0, 0, 0);
177 MMI::PointerEvent::PointerItem otherPoint = {};
178 SetTouchExplorationPoint(otherPoint, POINT_ID_1, 0, 0);
179 points.emplace_back(point);
180 points.emplace_back(otherPoint);
181 std::shared_ptr<MMI::PointerEvent> event =
182 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
183 touchExploration_->OnPointerEvent(*event);
184
185 usleep(SLEEP_US_50);
186
187 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
188 MMI::PointerEvent::POINTER_ACTION_DOWN);
189 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::PASSING_THROUGH);
190
191 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateDown_002 end";
192 }
193
194 /**
195 * @tc.number: HandleInitStateUp001
196 * @tc.name: HandleInitStateUp
197 * @tc.desc: Test func HandleInitStateUp.
198 */
199 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleInitStateUp_001, TestSize.Level0)
200 {
201 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateUp_001 start";
202
203 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
204
205 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
206 0, 0);
207 touchExploration_->OnPointerEvent(*event);
208
209 usleep(SLEEP_US_50);
210
211 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
212 MMI::PointerEvent::POINTER_ACTION_UP);
213 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
214
215 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateUp_001 end";
216 }
217
218 /**
219 * @tc.number: HandleInitStateUp002
220 * @tc.name: HandleInitStateUp
221 * @tc.desc: Test func HandleInitStateUp.
222 */
223 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleInitStateUp_002, TestSize.Level0)
224 {
225 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateUp_002 start";
226
227 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
228
229 std::vector<MMI::PointerEvent::PointerItem> points = {};
230 MMI::PointerEvent::PointerItem firstPoint = {};
231 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
232 points.emplace_back(firstPoint);
233 MMI::PointerEvent::PointerItem secondPoint = {};
234 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
235 points.emplace_back(secondPoint);
236 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
237 POINT_ID_1);
238 touchExploration_->OnPointerEvent(*event);
239
240 usleep(SLEEP_US_50);
241
242 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
243 MMI::PointerEvent::POINTER_ACTION_UP);
244 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::PASSING_THROUGH);
245
246 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateUp_002 end";
247 }
248
249 /**
250 * @tc.number: HandleInitStateMove001
251 * @tc.name: HandleInitStateMove
252 * @tc.desc: Test func HandleInitStateMove.
253 */
254 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleInitStateMove_001, TestSize.Level0)
255 {
256 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateMove_001 start";
257
258 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
259
260 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0,
261 0, 0);
262 touchExploration_->OnPointerEvent(*event);
263
264 usleep(SLEEP_US_50);
265
266 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
267 MMI::PointerEvent::POINTER_ACTION_MOVE);
268 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::PASSING_THROUGH);
269
270 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInitStateMove_001 end";
271 }
272
273 /**
274 * @tc.number: HandlePassingThroughState001
275 * @tc.name: HandlePassingThroughState
276 * @tc.desc: Test func HandlePassingThroughState.
277 */
278 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandlePassingThroughState_001, TestSize.Level0)
279 {
280 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandlePassingThroughState_001 start";
281
282 touchExploration_->SetCurrentState(TouchExplorationState::PASSING_THROUGH);
283
284 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
285 0, 0);
286 touchExploration_->OnPointerEvent(*event);
287
288 usleep(SLEEP_US_50);
289
290 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
291 MMI::PointerEvent::POINTER_ACTION_DOWN);
292 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::PASSING_THROUGH);
293
294 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandlePassingThroughState_001 end";
295 }
296
297 /**
298 * @tc.number: HandlePassingThroughState002
299 * @tc.name: HandlePassingThroughState
300 * @tc.desc: Test func HandlePassingThroughState.
301 */
302 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandlePassingThroughState_002, TestSize.Level0)
303 {
304 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandlePassingThroughState_002 start";
305
306 touchExploration_->SetCurrentState(TouchExplorationState::PASSING_THROUGH);
307
308 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
309 0, 0);
310 touchExploration_->OnPointerEvent(*event);
311
312 usleep(SLEEP_US_50);
313
314 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
315 MMI::PointerEvent::POINTER_ACTION_UP);
316 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
317
318 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandlePassingThroughState_002 end";
319 }
320
321 /**
322 * @tc.number: HandleInvalidState001
323 * @tc.name: HandleInvalidState
324 * @tc.desc: Test func HandleInvalidState.
325 */
326 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleInvalidState_001, TestSize.Level0)
327 {
328 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInvalidState_001 start";
329
330 touchExploration_->SetCurrentState(TouchExplorationState::INVALID);
331
332 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
333 0, 0);
334 touchExploration_->OnPointerEvent(*event);
335
336 usleep(SLEEP_US_50);
337
338 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0), ACTION_INVALID);
339 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
340
341 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInvalidState_001 end";
342 }
343
344 /**
345 * @tc.number: HandleInvalidState002
346 * @tc.name: HandleInvalidState
347 * @tc.desc: Test func HandleInvalidState.
348 */
349 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleInvalidState_002, TestSize.Level0)
350 {
351 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInvalidState_002 start";
352
353 touchExploration_->SetCurrentState(TouchExplorationState::INVALID);
354
355 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
356 0, 0);
357 touchExploration_->OnPointerEvent(*event);
358
359 usleep(SLEEP_US_50);
360
361 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0), ACTION_INVALID);
362 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
363
364 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleInvalidState_002 end";
365 }
366
367 /**
368 * @tc.number: HandleCancelEvent001
369 * @tc.name: HandleCancelEvent
370 * @tc.desc: Test func HandleCancelEvent.
371 */
372 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleCancelEvent_001, TestSize.Level0)
373 {
374 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleCancelEvent_001 start";
375
376 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
377
378 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_CANCEL, POINT_ID_0,
379 0, 0);
380 touchExploration_->OnPointerEvent(*event);
381
382 usleep(SLEEP_US_50);
383
384 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
385 MMI::PointerEvent::POINTER_ACTION_HOVER_CANCEL);
386
387 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleCancelEvent_001 end";
388 }
389
390 /**
391 * @tc.number: HandleOneFingerDownStateDown001
392 * @tc.name: HandleOneFingerDownStateDown
393 * @tc.desc: Test func HandleOneFingerDownStateDown.
394 */
395 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerDownStateDown_001, TestSize.Level0)
396 {
397 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerDownStateDown_001 start";
398
399 touchExploration_->SetCurrentState(TouchExplorationState::ONE_FINGER_DOWN);
400
401 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
402 0, 0);
403 touchExploration_->OnPointerEvent(*event);
404
405 usleep(SLEEP_US_50);
406
407 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0), ACTION_INVALID);
408 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_UNKNOWN);
409
410 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerDownStateDown_001 end";
411 }
412
413 /**
414 * @tc.number: HandleOneFingerDownStateUp001
415 * @tc.name: HandleOneFingerDownStateUp
416 * @tc.desc: Test func HandleOneFingerDownStateUp.
417 */
418 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerDownStateUp_001, TestSize.Level0)
419 {
420 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerDownStateUp_001 start";
421
422 touchExploration_->SetCurrentState(TouchExplorationState::ONE_FINGER_DOWN);
423
424 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
425 0, 0);
426 touchExploration_->OnPointerEvent(*event);
427
428 usleep(SLEEP_US_50);
429
430 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0), ACTION_INVALID);
431 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP);
432
433 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerDownStateUp_001 end";
434 }
435
436 /**
437 * @tc.number: HandleOneFingerDownStateMove001
438 * @tc.name: HandleOneFingerDownStateMove
439 * @tc.desc: Test func HandleOneFingerDownStateMove.
440 */
441 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerDownStateMove_001, TestSize.Level0)
442 {
443 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerDownStateMove_001 start";
444
445 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
446 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
447 0, 0);
448 touchExploration_->OnPointerEvent(*event);
449
450 usleep(SLEEP_US_50);
451
452 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_DOWN);
453
454 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, 0, 0);
455 touchExploration_->OnPointerEvent(*event);
456
457 usleep(SLEEP_US_50);
458
459 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_DOWN);
460
461 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerDownStateMove_001 end";
462 }
463
464 /**
465 * @tc.number: HandleOneFingerDownStateMove002
466 * @tc.name: HandleOneFingerDownStateMove
467 * @tc.desc: Test func HandleOneFingerDownStateMove.
468 */
469 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerDownStateMove_002, TestSize.Level0)
470 {
471 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerDownStateMove_002 start";
472
473 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
474 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
475 0, 0);
476 touchExploration_->OnPointerEvent(*event);
477
478 usleep(SLEEP_US_50);
479
480 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_DOWN);
481
482 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, 0, DISPLAY_500);
483 touchExploration_->OnPointerEvent(*event);
484
485 usleep(SLEEP_US_50);
486
487 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SWIPE);
488
489 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerDownStateMove_002 end";
490 }
491
492 /**
493 * @tc.number: HandleOneFingerLongPressStateDown001
494 * @tc.name: HandleOneFingerLongPressStateDown
495 * @tc.desc: Test func HandleOneFingerLongPressStateDown.
496 */
497 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerLongPressStateDown_001, TestSize.Level0)
498 {
499 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerLongPressStateDown_001 start";
500
501 touchExploration_->SetCurrentState(TouchExplorationState::ONE_FINGER_LONG_PRESS);
502 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_1,
503 0, 0);
504 touchExploration_->OnPointerEvent(*event);
505
506 usleep(SLEEP_US_50);
507
508 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_UNKNOWN);
509
510 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerLongPressStateDown_001 end";
511 }
512
513 /**
514 * @tc.number: HandleOneFingerLongPressStateUp001
515 * @tc.name: HandleOneFingerLongPressStateUp
516 * @tc.desc: Test func HandleOneFingerLongPressStateUp.
517 */
518 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerLongPressStateUp_001, TestSize.Level0)
519 {
520 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerLongPressStateUp_001 start";
521
522 touchExploration_->SetCurrentState(TouchExplorationState::ONE_FINGER_LONG_PRESS);
523 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
524 0, 0);
525 touchExploration_->OnPointerEvent(*event);
526
527 usleep(SLEEP_US_50);
528
529 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
530 MMI::PointerEvent::POINTER_ACTION_HOVER_EXIT);
531 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
532
533 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerLongPressStateUp_001 end";
534 }
535
536 /**
537 * @tc.number: HandleOneFingerLongPressStateMove001
538 * @tc.name: HandleOneFingerLongPressStateMove
539 * @tc.desc: Test func HandleOneFingerLongPressStateMove.
540 */
541 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerLongPressStateMove_001, TestSize.Level0)
542 {
543 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerLongPressStateMove_001 start";
544
545 touchExploration_->SetCurrentState(TouchExplorationState::ONE_FINGER_LONG_PRESS);
546 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0,
547 0, 0);
548 touchExploration_->OnPointerEvent(*event);
549
550 usleep(SLEEP_US_50);
551
552 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
553 MMI::PointerEvent::POINTER_ACTION_HOVER_MOVE);
554 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_LONG_PRESS);
555
556 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerLongPressStateMove_001 end";
557 }
558
559 /**
560 * @tc.number: HandleOneFingerSwipeStateDown001
561 * @tc.name: HandleOneFingerSwipeStateDown
562 * @tc.desc: Test func HandleOneFingerSwipeStateDown.
563 */
564 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSwipeStateDown_001, TestSize.Level0)
565 {
566 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSwipeStateDown_001 start";
567
568 touchExploration_->SetCurrentState(TouchExplorationState::ONE_FINGER_SWIPE);
569 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_1,
570 0, 0);
571 touchExploration_->OnPointerEvent(*event);
572
573 usleep(SLEEP_US_50);
574
575 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
576
577 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSwipeStateDown_001 end";
578 }
579
580 /**
581 * @tc.number: HandleOneFingerSwipeStateUp001
582 * @tc.name: HandleOneFingerSwipeStateUp
583 * @tc.desc: Test func HandleOneFingerSwipeStateUp.
584 */
585 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSwipeStateUp_001, TestSize.Level0)
586 {
587 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSwipeStateUp_001 start";
588
589 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
590 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
591 0, 0);
592 touchExploration_->OnPointerEvent(*event);
593
594 usleep(SLEEP_US_50);
595
596 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_DOWN);
597
598 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, DISPLAY_500, 0);
599 touchExploration_->OnPointerEvent(*event);
600
601 usleep(SLEEP_US_50);
602
603 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, DISPLAY_500, 0);
604 touchExploration_->OnPointerEvent(*event);
605
606 usleep(SLEEP_US_50);
607
608 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
609
610 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSwipeStateUp_001 end";
611 }
612
613 /**
614 * @tc.number: HandleOneFingerSwipeStateUp002
615 * @tc.name: HandleOneFingerSwipeStateUp
616 * @tc.desc: Test func HandleOneFingerSwipeStateUp.
617 */
618 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSwipeStateUp_002, TestSize.Level0)
619 {
620 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSwipeStateUp_002 start";
621
622 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
623 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
624 0, 0);
625 touchExploration_->OnPointerEvent(*event);
626
627 usleep(SLEEP_US_50);
628
629 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_DOWN);
630
631 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, DISPLAY_500, 0);
632 touchExploration_->OnPointerEvent(*event);
633
634 usleep(SLEEP_US_50);
635
636 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, DISPLAY_1000, 0);
637 touchExploration_->OnPointerEvent(*event);
638
639 usleep(SLEEP_US_50);
640
641 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, DISPLAY_1500, 0);
642 touchExploration_->OnPointerEvent(*event);
643
644 usleep(SLEEP_US_50);
645
646 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
647
648 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSwipeStateUp_002 end";
649 }
650
651 /**
652 * @tc.number: HandleOneFingerSingleTapStateDown001
653 * @tc.name: HandleOneFingerSingleTapStateDown
654 * @tc.desc: Test func HandleOneFingerSingleTapStateDown.
655 */
656 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSingleTapStateDown_001, TestSize.Level0)
657 {
658 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapStateDown_001 start";
659
660 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
661 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
662 0, 0);
663 touchExploration_->OnPointerEvent(*event);
664
665 usleep(SLEEP_US_50);
666
667 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
668 touchExploration_->OnPointerEvent(*event);
669
670 usleep(SLEEP_US_50);
671
672 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP);
673
674 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0, 0, 0);
675 touchExploration_->OnPointerEvent(*event);
676
677 usleep(SLEEP_US_50);
678
679 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP_THEN_DOWN);
680
681 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapStateDown_001 end";
682 }
683
684 /**
685 * @tc.number: HandleOneFingerSingleTapStateDown002
686 * @tc.name: HandleOneFingerSingleTapStateDown
687 * @tc.desc: Test func HandleOneFingerSingleTapStateDown.
688 */
689 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSingleTapStateDown_002, TestSize.Level0)
690 {
691 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapStateDown_002 start";
692
693 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
694 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
695 0, 0);
696 touchExploration_->OnPointerEvent(*event);
697
698 usleep(SLEEP_US_50);
699
700 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
701 touchExploration_->OnPointerEvent(*event);
702
703 usleep(SLEEP_US_50);
704
705 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP);
706
707 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0, DISPLAY_500, DISPLAY_500);
708 touchExploration_->OnPointerEvent(*event);
709
710 usleep(SLEEP_US_50);
711
712 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_DOWN);
713
714 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapStateDown_002 end";
715 }
716
717 /**
718 * @tc.number: HandleOneFingerSingleTapThenDownStateDown001
719 * @tc.name: HandleOneFingerSingleTapThenDownStateDown
720 * @tc.desc: Test func HandleOneFingerSingleTapThenDownStateDown.
721 */
722 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateDown_001, TestSize.Level0)
723 {
724 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateDown_001 start";
725
726 touchExploration_->SetCurrentState(TouchExplorationState::ONE_FINGER_SINGLE_TAP_THEN_DOWN);
727 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_1,
728 0, 0);
729 touchExploration_->OnPointerEvent(*event);
730
731 usleep(SLEEP_US_50);
732
733 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
734
735 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateDown_001 end";
736 }
737
738 /**
739 * @tc.number: HandleOneFingerSingleTapThenDownStateUp001
740 * @tc.name: HandleOneFingerSingleTapThenDownStateUp
741 * @tc.desc: Test func HandleOneFingerSingleTapThenDownStateUp.
742 */
743 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateUp_001, TestSize.Level0)
744 {
745 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateUp_001 start";
746
747 touchExploration_->SetCurrentState(TouchExplorationState::ONE_FINGER_SINGLE_TAP_THEN_DOWN);
748 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
749 0, 0);
750 touchExploration_->OnPointerEvent(*event);
751
752 usleep(SLEEP_US_50);
753
754 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
755
756 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateUp_001 end";
757 }
758
759 /**
760 * @tc.number: HandleOneFingerSingleTapThenDownStateMove001
761 * @tc.name: HandleOneFingerSingleTapThenDownStateMove
762 * @tc.desc: Test func HandleOneFingerSingleTapThenDownStateMove.
763 */
764 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateMove_001, TestSize.Level0)
765 {
766 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateMove_001 start";
767
768 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
769 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
770 0, 0);
771 touchExploration_->OnPointerEvent(*event);
772
773 usleep(SLEEP_US_50);
774
775 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
776 touchExploration_->OnPointerEvent(*event);
777
778 usleep(SLEEP_US_50);
779
780 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP);
781
782 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0, 0, 0);
783 touchExploration_->OnPointerEvent(*event);
784
785 usleep(SLEEP_US_50);
786
787 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP_THEN_DOWN);
788
789 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, 0, 0);
790 touchExploration_->OnPointerEvent(*event);
791
792 usleep(SLEEP_US_50);
793
794 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP_THEN_DOWN);
795
796 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateMove_001 end";
797 }
798
799 /**
800 * @tc.number: HandleOneFingerSingleTapThenDownStateMove002
801 * @tc.name: HandleOneFingerSingleTapThenDownStateMove
802 * @tc.desc: Test func HandleOneFingerSingleTapThenDownStateMove.
803 */
804 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateMove_002, TestSize.Level0)
805 {
806 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateMove_002 start";
807
808 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
809 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
810 0, 0);
811 touchExploration_->OnPointerEvent(*event);
812
813 usleep(SLEEP_US_50);
814
815 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
816 touchExploration_->OnPointerEvent(*event);
817
818 usleep(SLEEP_US_50);
819
820 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP);
821
822 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0, 0, 0);
823 touchExploration_->OnPointerEvent(*event);
824
825 usleep(SLEEP_US_50);
826
827 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::ONE_FINGER_SINGLE_TAP_THEN_DOWN);
828
829 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, DISPLAY_500, DISPLAY_500);
830 touchExploration_->OnPointerEvent(*event);
831
832 usleep(SLEEP_US_50);
833
834 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
835
836 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleOneFingerSingleTapThenDownStateMove_002 end";
837 }
838
839 /**
840 * @tc.number: HandleTwoFingersDownStateDown001
841 * @tc.name: HandleTwoFingersDownStateDown
842 * @tc.desc: Test func HandleTwoFingersDownStateDown.
843 */
844 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateDown_001, TestSize.Level0)
845 {
846 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateDown_001 start";
847
848 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DOWN);
849 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
850 0, 0);
851 touchExploration_->OnPointerEvent(*event);
852
853 usleep(SLEEP_US_50);
854
855 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
856
857 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateDown_001 end";
858 }
859
860 /**
861 * @tc.number: HandleTwoFingersDownStateDown002
862 * @tc.name: HandleTwoFingersDownStateDown
863 * @tc.desc: Test func HandleTwoFingersDownStateDown.
864 */
865 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateDown_002, TestSize.Level0)
866 {
867 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateDown_002 start";
868
869 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DOWN);
870
871 std::vector<MMI::PointerEvent::PointerItem> points = {};
872 MMI::PointerEvent::PointerItem firstPoint = {};
873 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
874 MMI::PointerEvent::PointerItem secondPoint = {};
875 SetTouchExplorationPoint(secondPoint, POINT_ID_1, 0, 0);
876 MMI::PointerEvent::PointerItem thirdPoint = {};
877 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, 0, 0);
878 points.emplace_back(firstPoint);
879 points.emplace_back(secondPoint);
880 points.emplace_back(thirdPoint);
881 std::shared_ptr<MMI::PointerEvent> event =
882 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_0);
883 touchExploration_->OnPointerEvent(*event);
884
885 usleep(SLEEP_US_50);
886
887 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
888
889 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateDown_002 end";
890 }
891
892 /**
893 * @tc.number: HandleTwoFingersDownStateDown003
894 * @tc.name: HandleTwoFingersDownStateDown
895 * @tc.desc: Test func HandleTwoFingersDownStateDown.
896 */
897 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateDown_003, TestSize.Level0)
898 {
899 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateDown_003 start";
900
901 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
902 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
903 0, 0);
904 touchExploration_->OnPointerEvent(*event);
905
906 usleep(SLEEP_US_50);
907
908 std::vector<MMI::PointerEvent::PointerItem> points = {};
909 MMI::PointerEvent::PointerItem firstPoint = {};
910 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
911 MMI::PointerEvent::PointerItem secondPoint = {};
912 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
913 points.emplace_back(firstPoint);
914 points.emplace_back(secondPoint);
915 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
916 touchExploration_->OnPointerEvent(*event);
917
918 usleep(SLEEP_US_50);
919
920 MMI::PointerEvent::PointerItem thirdPoint = {};
921 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, 0, 0);
922 points.emplace_back(thirdPoint);
923 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2);
924 touchExploration_->OnPointerEvent(*event);
925
926 usleep(SLEEP_US_50);
927
928 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::THREE_FINGERS_DOWN);
929
930 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateDown_003 end";
931 }
932
933 /**
934 * @tc.number: HandleTwoFingersDownStateUp001
935 * @tc.name: HandleTwoFingersDownStateUp
936 * @tc.desc: Test func HandleTwoFingersDownStateUp.
937 */
938 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateUp_001, TestSize.Level0)
939 {
940 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateUp_001 start";
941
942 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DOWN);
943
944 std::vector<MMI::PointerEvent::PointerItem> points = {};
945 MMI::PointerEvent::PointerItem firstPoint = {};
946 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
947 MMI::PointerEvent::PointerItem secondPoint = {};
948 SetTouchExplorationPoint(secondPoint, POINT_ID_1, 0, 0);
949 points.emplace_back(firstPoint);
950 points.emplace_back(secondPoint);
951 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
952 POINT_ID_1);
953 touchExploration_->OnPointerEvent(*event);
954
955 usleep(SLEEP_US_50);
956
957 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_DOWN);
958
959 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateUp_001 end";
960 }
961
962 /**
963 * @tc.number: HandleTwoFingersDownStateUp002
964 * @tc.name: HandleTwoFingersDownStateUp
965 * @tc.desc: Test func HandleTwoFingersDownStateUp.
966 */
967 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateUp_002, TestSize.Level0)
968 {
969 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateUp_002 start";
970
971 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DOWN);
972 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
973 0, 0);
974 touchExploration_->OnPointerEvent(*event);
975
976 usleep(SLEEP_US_50);
977
978 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_TAP);
979
980 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateUp_002 end";
981 }
982
983 /**
984 * @tc.number: HandleTwoFingersDownStateUp003
985 * @tc.name: HandleTwoFingersDownStateUp
986 * @tc.desc: Test func HandleTwoFingersDownStateUp.
987 */
988 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateUp_003, TestSize.Level0)
989 {
990 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateUp_003 start";
991
992 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DOWN);
993
994 std::vector<MMI::PointerEvent::PointerItem> points = {};
995 MMI::PointerEvent::PointerItem firstPoint = {};
996 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
997 MMI::PointerEvent::PointerItem secondPoint = {};
998 SetTouchExplorationPoint(secondPoint, POINT_ID_1, 0, 0);
999 MMI::PointerEvent::PointerItem thirdPoint = {};
1000 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, 0, 0);
1001 points.emplace_back(firstPoint);
1002 points.emplace_back(secondPoint);
1003 points.emplace_back(thirdPoint);
1004 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
1005 POINT_ID_2);
1006 touchExploration_->OnPointerEvent(*event);
1007
1008 usleep(SLEEP_US_50);
1009
1010 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1011
1012 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateUp_003 end";
1013 }
1014
1015 /**
1016 * @tc.number: HandleTwoFingersDownStateMove001
1017 * @tc.name: HandleTwoFingersDownStateMove
1018 * @tc.desc: Test func HandleTwoFingersDownStateMove.
1019 */
1020 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateMove_001, TestSize.Level0)
1021 {
1022 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateMove_001 start";
1023
1024 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1025
1026 std::vector<MMI::PointerEvent::PointerItem> points = {};
1027 MMI::PointerEvent::PointerItem firstPoint = {};
1028 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1029 points.emplace_back(firstPoint);
1030 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1031 POINT_ID_0);
1032 touchExploration_->OnPointerEvent(*event);
1033
1034 usleep(SLEEP_US_50);
1035
1036 MMI::PointerEvent::PointerItem secondPoint = {};
1037 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1038 points.emplace_back(secondPoint);
1039 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1040 touchExploration_->OnPointerEvent(*event);
1041
1042 usleep(SLEEP_US_50);
1043
1044 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_1);
1045 touchExploration_->OnPointerEvent(*event);
1046
1047 usleep(SLEEP_US_50);
1048
1049 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_DOWN);
1050
1051 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateMove_001 end";
1052 }
1053
1054 /**
1055 * @tc.number: HandleTwoFingersDownStateMove002
1056 * @tc.name: HandleTwoFingersDownStateMove
1057 * @tc.desc: Test func HandleTwoFingersDownStateMove.
1058 */
1059 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateMove_002, TestSize.Level0)
1060 {
1061 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateMove_002 start";
1062
1063 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1064
1065 std::vector<MMI::PointerEvent::PointerItem> points = {};
1066 MMI::PointerEvent::PointerItem firstPoint = {};
1067 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1068 points.emplace_back(firstPoint);
1069 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1070 POINT_ID_0);
1071 touchExploration_->OnPointerEvent(*event);
1072
1073 usleep(SLEEP_US_50);
1074
1075 MMI::PointerEvent::PointerItem secondPoint = {};
1076 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1077 points.emplace_back(secondPoint);
1078 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1079 touchExploration_->OnPointerEvent(*event);
1080
1081 usleep(SLEEP_US_50);
1082
1083 points.clear();
1084 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, DISPLAY_500);
1085 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, DISPLAY_500);
1086 points.emplace_back(firstPoint);
1087 points.emplace_back(secondPoint);
1088 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_1);
1089 touchExploration_->OnPointerEvent(*event);
1090
1091 usleep(SLEEP_US_50);
1092
1093 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
1094 MMI::PointerEvent::POINTER_ACTION_DOWN);
1095 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1),
1096 MMI::PointerEvent::POINTER_ACTION_MOVE);
1097 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_DRAG);
1098
1099 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateMove_002 end";
1100 }
1101
1102 /**
1103 * @tc.number: HandleTwoFingersDownStateMove003
1104 * @tc.name: HandleTwoFingersDownStateMove
1105 * @tc.desc: Test func HandleTwoFingersDownStateMove.
1106 */
1107 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDownStateMove_003, TestSize.Level0)
1108 {
1109 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateMove_003 start";
1110
1111 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1112
1113 std::vector<MMI::PointerEvent::PointerItem> points = {};
1114 MMI::PointerEvent::PointerItem firstPoint = {};
1115 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1116 points.emplace_back(firstPoint);
1117 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1118 POINT_ID_0);
1119 touchExploration_->OnPointerEvent(*event);
1120
1121 usleep(SLEEP_US_50);
1122
1123 MMI::PointerEvent::PointerItem secondPoint = {};
1124 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1125 points.emplace_back(secondPoint);
1126 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1127 touchExploration_->OnPointerEvent(*event);
1128
1129 usleep(SLEEP_US_50);
1130
1131 points.clear();
1132 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, DISPLAY_500);
1133 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_500, 0);
1134 points.emplace_back(firstPoint);
1135 points.emplace_back(secondPoint);
1136 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_1);
1137 touchExploration_->OnPointerEvent(*event);
1138
1139 usleep(SLEEP_US_50);
1140
1141 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
1142 MMI::PointerEvent::POINTER_ACTION_DOWN);
1143 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1),
1144 MMI::PointerEvent::POINTER_ACTION_DOWN);
1145 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2),
1146 MMI::PointerEvent::POINTER_ACTION_MOVE);
1147 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::PASSING_THROUGH);
1148
1149 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDownStateMove_003 end";
1150 }
1151
1152 /**
1153 * @tc.number: HandleTwoFingersDragStateDown001
1154 * @tc.name: HandleTwoFingersDragStateDown
1155 * @tc.desc: Test func HandleTwoFingersDragStateDown.
1156 */
1157 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDragStateDown_001, TestSize.Level0)
1158 {
1159 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateDown_001 start";
1160
1161 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DRAG);
1162 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
1163 0, 0);
1164 touchExploration_->OnPointerEvent(*event);
1165
1166 usleep(SLEEP_US_50);
1167
1168 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1169
1170 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateDown_001 end";
1171 }
1172
1173 /**
1174 * @tc.number: HandleTwoFingersDragStateDown002
1175 * @tc.name: HandleTwoFingersDragStateDown
1176 * @tc.desc: Test func HandleTwoFingersDragStateDown.
1177 */
1178 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDragStateDown_002, TestSize.Level0)
1179 {
1180 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateDown_002 start";
1181
1182 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DRAG);
1183
1184 std::vector<MMI::PointerEvent::PointerItem> points = {};
1185 MMI::PointerEvent::PointerItem firstPoint = {};
1186 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1187 points.emplace_back(firstPoint);
1188 MMI::PointerEvent::PointerItem secondPoint = {};
1189 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1190 points.emplace_back(secondPoint);
1191 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1192 POINT_ID_1);
1193 touchExploration_->OnPointerEvent(*event);
1194
1195 usleep(SLEEP_US_50);
1196
1197 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_DRAG);
1198
1199 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateDown_002 end";
1200 }
1201
1202 /**
1203 * @tc.number: HandleTwoFingersDragStateUp001
1204 * @tc.name: HandleTwoFingersDragStateUp
1205 * @tc.desc: Test func HandleTwoFingersDragStateUp.
1206 */
1207 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDragStateUp_001, TestSize.Level0)
1208 {
1209 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateUp_001 start";
1210
1211 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DRAG);
1212 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
1213 0, 0);
1214 touchExploration_->OnPointerEvent(*event);
1215
1216 usleep(SLEEP_US_50);
1217
1218 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
1219
1220 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateUp_001 end";
1221 }
1222
1223 /**
1224 * @tc.number: HandleTwoFingersDragStateUp002
1225 * @tc.name: HandleTwoFingersDragStateUp
1226 * @tc.desc: Test func HandleTwoFingersDragStateUp.
1227 */
1228 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDragStateUp_002, TestSize.Level0)
1229 {
1230 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateUp_002 start";
1231
1232 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DRAG);
1233
1234 std::vector<MMI::PointerEvent::PointerItem> points = {};
1235 MMI::PointerEvent::PointerItem firstPoint = {};
1236 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1237 points.emplace_back(firstPoint);
1238 MMI::PointerEvent::PointerItem secondPoint = {};
1239 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1240 points.emplace_back(secondPoint);
1241 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
1242 POINT_ID_1);
1243 touchExploration_->OnPointerEvent(*event);
1244
1245 usleep(SLEEP_US_50);
1246
1247 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_DRAG);
1248
1249 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateUp_002 end";
1250 }
1251
1252 /**
1253 * @tc.number: HandleTwoFingersDragStateMove001
1254 * @tc.name: HandleTwoFingersDragStateMove
1255 * @tc.desc: Test func HandleTwoFingersDragStateMove.
1256 */
1257 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDragStateMove_001, TestSize.Level0)
1258 {
1259 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateMove_001 start";
1260
1261 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_DRAG);
1262 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0,
1263 0, 0);
1264 touchExploration_->OnPointerEvent(*event);
1265
1266 usleep(SLEEP_US_50);
1267
1268 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0), ACTION_INVALID);
1269
1270 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateMove_001 end";
1271 }
1272
1273 /**
1274 * @tc.number: HandleTwoFingersDragStateMove002
1275 * @tc.name: HandleTwoFingersDragStateMove
1276 * @tc.desc: Test func HandleTwoFingersDragStateMove.
1277 */
1278 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersDragStateMove_002, TestSize.Level0)
1279 {
1280 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateMove_002 start";
1281
1282 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1283
1284 std::vector<MMI::PointerEvent::PointerItem> points = {};
1285 MMI::PointerEvent::PointerItem firstPoint = {};
1286 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1287 points.emplace_back(firstPoint);
1288 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1289 POINT_ID_0);
1290 touchExploration_->OnPointerEvent(*event);
1291
1292 usleep(SLEEP_US_50);
1293
1294 MMI::PointerEvent::PointerItem secondPoint = {};
1295 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1296 points.emplace_back(secondPoint);
1297 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1298 touchExploration_->OnPointerEvent(*event);
1299
1300 usleep(SLEEP_US_50);
1301
1302 points.clear();
1303 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, DISPLAY_500);
1304 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, DISPLAY_500);
1305 points.emplace_back(firstPoint);
1306 points.emplace_back(secondPoint);
1307 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_1);
1308 touchExploration_->OnPointerEvent(*event);
1309
1310 usleep(SLEEP_US_50);
1311
1312 points.clear();
1313 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, DISPLAY_1000);
1314 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, DISPLAY_1000);
1315 points.emplace_back(firstPoint);
1316 points.emplace_back(secondPoint);
1317 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_1);
1318 touchExploration_->OnPointerEvent(*event);
1319
1320 usleep(SLEEP_US_50);
1321
1322 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0),
1323 MMI::PointerEvent::POINTER_ACTION_DOWN);
1324 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1),
1325 MMI::PointerEvent::POINTER_ACTION_MOVE);
1326 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2),
1327 MMI::PointerEvent::POINTER_ACTION_MOVE);
1328
1329 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersDragStateMove_002 end";
1330 }
1331
1332 /**
1333 * @tc.number: HandleMultiFingersTapStateDown001
1334 * @tc.name: HandleMultiFingersTapStateDown
1335 * @tc.desc: Test func HandleMultiFingersTapStateDown.
1336 */
1337 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersTapStateDown_001, TestSize.Level0)
1338 {
1339 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateDown_001 start";
1340
1341 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_TAP);
1342 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
1343 0, 0);
1344 touchExploration_->OnPointerEvent(*event);
1345
1346 usleep(SLEEP_US_50);
1347
1348 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_TAP);
1349
1350 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateDown_001 end";
1351 }
1352
1353 /**
1354 * @tc.number: HandleMultiFingersTapStateDown002
1355 * @tc.name: HandleMultiFingersTapStateDown
1356 * @tc.desc: Test func HandleMultiFingersTapStateDown.
1357 */
1358 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersTapStateDown_002, TestSize.Level0)
1359 {
1360 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateDown_002 start";
1361
1362 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_TAP);
1363
1364 std::vector<MMI::PointerEvent::PointerItem> points = {};
1365 MMI::PointerEvent::PointerItem firstPoint = {};
1366 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1367 points.emplace_back(firstPoint);
1368 MMI::PointerEvent::PointerItem secondPoint = {};
1369 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1370 points.emplace_back(secondPoint);
1371 MMI::PointerEvent::PointerItem thirdPoint = {};
1372 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, DISPLAY_10 + DISPLAY_10, 0);
1373 points.emplace_back(thirdPoint);
1374 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1375 POINT_ID_2);
1376 touchExploration_->OnPointerEvent(*event);
1377
1378 usleep(SLEEP_US_50);
1379
1380 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1381
1382 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateDown_002 end";
1383 }
1384
1385 /**
1386 * @tc.number: HandleMultiFingersTapStateDown003
1387 * @tc.name: HandleMultiFingersTapStateDown
1388 * @tc.desc: Test func HandleMultiFingersTapStateDown.
1389 */
1390 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersTapStateDown_003, TestSize.Level0)
1391 {
1392 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateDown_003 start";
1393
1394 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1395
1396 std::vector<MMI::PointerEvent::PointerItem> points = {};
1397 MMI::PointerEvent::PointerItem firstPoint = {};
1398 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1399 points.emplace_back(firstPoint);
1400 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1401 POINT_ID_0);
1402 touchExploration_->OnPointerEvent(*event);
1403
1404 usleep(SLEEP_US_50);
1405
1406 MMI::PointerEvent::PointerItem secondPoint = {};
1407 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1408 points.emplace_back(secondPoint);
1409 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1410 touchExploration_->OnPointerEvent(*event);
1411
1412 usleep(SLEEP_US_50);
1413
1414 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_1);
1415 touchExploration_->OnPointerEvent(*event);
1416
1417 usleep(SLEEP_US_50);
1418
1419 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
1420 touchExploration_->OnPointerEvent(*event);
1421
1422 usleep(SLEEP_US_50);
1423
1424 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0, 0, 0);
1425 touchExploration_->OnPointerEvent(*event);
1426
1427 usleep(SLEEP_US_50);
1428
1429 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1430 touchExploration_->OnPointerEvent(*event);
1431
1432 usleep(SLEEP_US_50);
1433
1434 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_CONTINUE_DOWN);
1435
1436 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateDown_003 end";
1437 }
1438
1439 /**
1440 * @tc.number: HandleMultiFingersTapStateUp001
1441 * @tc.name: HandleMultiFingersTapStateUp
1442 * @tc.desc: Test func HandleMultiFingersTapStateUp.
1443 */
1444 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersTapStateUp_001, TestSize.Level0)
1445 {
1446 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateUp_001 start";
1447
1448 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_TAP);
1449 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
1450 0, 0);
1451 touchExploration_->OnPointerEvent(*event);
1452
1453 usleep(SLEEP_US_50);
1454
1455 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
1456
1457 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateUp_001 end";
1458 }
1459
1460 /**
1461 * @tc.number: HandleMultiFingersTapStateUp002
1462 * @tc.name: HandleMultiFingersTapStateUp
1463 * @tc.desc: Test func HandleMultiFingersTapStateUp.
1464 */
1465 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersTapStateUp_002, TestSize.Level0)
1466 {
1467 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateUp_002 start";
1468
1469 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_TAP);
1470
1471 std::vector<MMI::PointerEvent::PointerItem> points = {};
1472 MMI::PointerEvent::PointerItem firstPoint = {};
1473 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1474 points.emplace_back(firstPoint);
1475 MMI::PointerEvent::PointerItem secondPoint = {};
1476 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1477 points.emplace_back(secondPoint);
1478 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
1479 POINT_ID_1);
1480 touchExploration_->OnPointerEvent(*event);
1481
1482 usleep(SLEEP_US_50);
1483
1484 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1485
1486 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateUp_002 end";
1487 }
1488
1489 /**
1490 * @tc.number: HandleMultiFingersTapStateMove001
1491 * @tc.name: HandleMultiFingersTapStateMove
1492 * @tc.desc: Test func HandleMultiFingersTapStateMove.
1493 */
1494 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersTapStateMove_001, TestSize.Level0)
1495 {
1496 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateMove_001 start";
1497
1498 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_TAP);
1499
1500 std::vector<MMI::PointerEvent::PointerItem> points = {};
1501 MMI::PointerEvent::PointerItem firstPoint = {};
1502 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1503 points.emplace_back(firstPoint);
1504 MMI::PointerEvent::PointerItem secondPoint = {};
1505 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1506 points.emplace_back(secondPoint);
1507 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points,
1508 POINT_ID_1);
1509 touchExploration_->OnPointerEvent(*event);
1510
1511 usleep(SLEEP_US_50);
1512
1513 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1514
1515 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateMove_001 end";
1516 }
1517
1518 /**
1519 * @tc.number: HandleMultiFingersTapStateMove002
1520 * @tc.name: HandleMultiFingersTapStateMove
1521 * @tc.desc: Test func HandleMultiFingersTapStateMove.
1522 */
1523 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersTapStateMove_002, TestSize.Level0)
1524 {
1525 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateMove_002 start";
1526
1527 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1528
1529 std::vector<MMI::PointerEvent::PointerItem> points = {};
1530 MMI::PointerEvent::PointerItem firstPoint = {};
1531 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1532 points.emplace_back(firstPoint);
1533 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1534 POINT_ID_0);
1535 touchExploration_->OnPointerEvent(*event);
1536
1537 usleep(SLEEP_US_50);
1538
1539 MMI::PointerEvent::PointerItem secondPoint = {};
1540 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1541 points.emplace_back(secondPoint);
1542 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1543 touchExploration_->OnPointerEvent(*event);
1544
1545 usleep(SLEEP_US_50);
1546
1547 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_1);
1548 touchExploration_->OnPointerEvent(*event);
1549
1550 usleep(SLEEP_US_50);
1551
1552 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
1553 touchExploration_->OnPointerEvent(*event);
1554
1555 usleep(SLEEP_US_50);
1556
1557 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, 0, 0);
1558 touchExploration_->OnPointerEvent(*event);
1559
1560 usleep(SLEEP_US_50);
1561
1562 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_TAP);
1563
1564 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateMove_002 end";
1565 }
1566
1567 /**
1568 * @tc.number: HandleMultiFingersTapStateMove003
1569 * @tc.name: HandleMultiFingersTapStateMove
1570 * @tc.desc: Test func HandleMultiFingersTapStateMove.
1571 */
1572 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersTapStateMove_003, TestSize.Level0)
1573 {
1574 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateMove_003 start";
1575
1576 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1577
1578 std::vector<MMI::PointerEvent::PointerItem> points = {};
1579 MMI::PointerEvent::PointerItem firstPoint = {};
1580 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1581 points.emplace_back(firstPoint);
1582 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1583 POINT_ID_0);
1584 touchExploration_->OnPointerEvent(*event);
1585
1586 usleep(SLEEP_US_50);
1587
1588 MMI::PointerEvent::PointerItem secondPoint = {};
1589 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1590 points.emplace_back(secondPoint);
1591 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1592 touchExploration_->OnPointerEvent(*event);
1593
1594 usleep(SLEEP_US_50);
1595
1596 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_1);
1597 touchExploration_->OnPointerEvent(*event);
1598
1599 usleep(SLEEP_US_50);
1600
1601 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
1602 touchExploration_->OnPointerEvent(*event);
1603
1604 usleep(SLEEP_US_50);
1605
1606 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0, DISPLAY_500, 0);
1607 touchExploration_->OnPointerEvent(*event);
1608
1609 usleep(SLEEP_US_50);
1610
1611 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1612
1613 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersTapStateMove_003 end";
1614 }
1615
1616 /**
1617 * @tc.number: HandleMultiFingersContinueDownStateDown001
1618 * @tc.name: HandleMultiFingersContinueDownStateDown
1619 * @tc.desc: Test func HandleMultiFingersContinueDownStateDown.
1620 */
1621 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersContinueDownStateDown_001, TestSize.Level0)
1622 {
1623 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateDown_001 start";
1624
1625 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_CONTINUE_DOWN);
1626 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
1627 0, 0);
1628 touchExploration_->OnPointerEvent(*event);
1629
1630 usleep(SLEEP_US_50);
1631
1632 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1633
1634 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateDown_001 end";
1635 }
1636
1637 /**
1638 * @tc.number: HandleMultiFingersContinueDownStateUp001
1639 * @tc.name: HandleMultiFingersContinueDownStateUp
1640 * @tc.desc: Test func HandleMultiFingersContinueDownStateUp.
1641 */
1642 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_001, TestSize.Level0)
1643 {
1644 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_001 start";
1645
1646 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_CONTINUE_DOWN);
1647 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
1648 0, 0);
1649 touchExploration_->OnPointerEvent(*event);
1650
1651 usleep(SLEEP_US_50);
1652
1653 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_TAP);
1654
1655 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_001 end";
1656 }
1657
1658 /**
1659 * @tc.number: HandleMultiFingersContinueDownStateUp002
1660 * @tc.name: HandleMultiFingersContinueDownStateUp
1661 * @tc.desc: Test func HandleMultiFingersContinueDownStateUp.
1662 */
1663 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_002, TestSize.Level0)
1664 {
1665 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_002 start";
1666
1667 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_CONTINUE_DOWN);
1668
1669 std::vector<MMI::PointerEvent::PointerItem> points = {};
1670 MMI::PointerEvent::PointerItem firstPoint = {};
1671 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1672 points.emplace_back(firstPoint);
1673 MMI::PointerEvent::PointerItem secondPoint = {};
1674 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1675 points.emplace_back(secondPoint);
1676 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
1677 POINT_ID_1);
1678 touchExploration_->OnPointerEvent(*event);
1679
1680 usleep(SLEEP_US_50);
1681
1682 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_CONTINUE_DOWN);
1683
1684 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_002 end";
1685 }
1686
1687 /**
1688 * @tc.number: HandleMultiFingersContinueDownStateUp003
1689 * @tc.name: HandleMultiFingersContinueDownStateUp
1690 * @tc.desc: Test func HandleMultiFingersContinueDownStateUp.
1691 */
1692 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_003, TestSize.Level0)
1693 {
1694 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_003 start";
1695
1696 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_CONTINUE_DOWN);
1697
1698 std::vector<MMI::PointerEvent::PointerItem> points = {};
1699 MMI::PointerEvent::PointerItem firstPoint = {};
1700 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1701 points.emplace_back(firstPoint);
1702 MMI::PointerEvent::PointerItem secondPoint = {};
1703 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1704 points.emplace_back(secondPoint);
1705 MMI::PointerEvent::PointerItem thirdPoint = {};
1706 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, DISPLAY_10, 0);
1707 points.emplace_back(thirdPoint);
1708 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
1709 POINT_ID_2);
1710 touchExploration_->OnPointerEvent(*event);
1711
1712 usleep(SLEEP_US_50);
1713
1714 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1715
1716 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_003 end";
1717 }
1718
1719 /**
1720 * @tc.number: HandleMultiFingersContinueDownStateUp004
1721 * @tc.name: HandleMultiFingersContinueDownStateUp
1722 * @tc.desc: Test func HandleMultiFingersContinueDownStateUp.
1723 */
1724 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_004, TestSize.Level0)
1725 {
1726 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_004 start";
1727
1728 touchExploration_->SetCurrentState(TouchExplorationState::THREE_FINGERS_CONTINUE_DOWN);
1729 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
1730 0, 0);
1731 touchExploration_->OnPointerEvent(*event);
1732
1733 usleep(SLEEP_US_50);
1734
1735 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::THREE_FINGERS_TAP);
1736
1737 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_004 end";
1738 }
1739
1740 /**
1741 * @tc.number: HandleMultiFingersContinueDownStateUp005
1742 * @tc.name: HandleMultiFingersContinueDownStateUp
1743 * @tc.desc: Test func HandleMultiFingersContinueDownStateUp.
1744 */
1745 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_005, TestSize.Level0)
1746 {
1747 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_005 start";
1748
1749 touchExploration_->SetCurrentState(TouchExplorationState::FOUR_FINGERS_CONTINUE_DOWN);
1750 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
1751 0, 0);
1752 touchExploration_->OnPointerEvent(*event);
1753
1754 usleep(SLEEP_US_50);
1755
1756 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::FOUR_FINGERS_TAP);
1757
1758 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateUp_005 end";
1759 }
1760
1761 /**
1762 * @tc.number: HandleMultiFingersContinueDownStateMove001
1763 * @tc.name: HandleMultiFingersContinueDownStateMove
1764 * @tc.desc: Test func HandleMultiFingersContinueDownStateMove.
1765 */
1766 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersContinueDownStateMove_001, TestSize.Level0)
1767 {
1768 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateMove_001 start";
1769
1770 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1771
1772 std::vector<MMI::PointerEvent::PointerItem> points = {};
1773 MMI::PointerEvent::PointerItem firstPoint = {};
1774 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1775 points.emplace_back(firstPoint);
1776 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1777 POINT_ID_0);
1778 touchExploration_->OnPointerEvent(*event);
1779
1780 usleep(SLEEP_US_50);
1781
1782 MMI::PointerEvent::PointerItem secondPoint = {};
1783 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1784 points.emplace_back(secondPoint);
1785 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1786 touchExploration_->OnPointerEvent(*event);
1787
1788 usleep(SLEEP_US_50);
1789
1790 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_1);
1791 touchExploration_->OnPointerEvent(*event);
1792 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
1793 touchExploration_->OnPointerEvent(*event);
1794
1795 usleep(SLEEP_US_50);
1796
1797 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0, 0, 0);
1798 touchExploration_->OnPointerEvent(*event);
1799 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1800 touchExploration_->OnPointerEvent(*event);
1801
1802 usleep(SLEEP_US_50);
1803
1804 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_1);
1805 touchExploration_->OnPointerEvent(*event);
1806
1807 usleep(SLEEP_US_50);
1808
1809 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_CONTINUE_DOWN);
1810
1811 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateMove_001 end";
1812 }
1813
1814 /**
1815 * @tc.number: HandleMultiFingersContinueDownStateMove002
1816 * @tc.name: HandleMultiFingersContinueDownStateMove
1817 * @tc.desc: Test func HandleMultiFingersContinueDownStateMove.
1818 */
1819 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleMultiFingersContinueDownStateMove_002, TestSize.Level0)
1820 {
1821 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateMove_002 start";
1822
1823 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
1824
1825 std::vector<MMI::PointerEvent::PointerItem> points = {};
1826 MMI::PointerEvent::PointerItem firstPoint = {};
1827 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1828 points.emplace_back(firstPoint);
1829 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1830 POINT_ID_0);
1831 touchExploration_->OnPointerEvent(*event);
1832
1833 usleep(SLEEP_US_50);
1834
1835 MMI::PointerEvent::PointerItem secondPoint = {};
1836 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1837 points.emplace_back(secondPoint);
1838 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1839 touchExploration_->OnPointerEvent(*event);
1840
1841 usleep(SLEEP_US_50);
1842
1843 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_1);
1844 touchExploration_->OnPointerEvent(*event);
1845 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0, 0, 0);
1846 touchExploration_->OnPointerEvent(*event);
1847
1848 usleep(SLEEP_US_50);
1849
1850 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0, 0, 0);
1851 touchExploration_->OnPointerEvent(*event);
1852 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
1853 touchExploration_->OnPointerEvent(*event);
1854
1855 usleep(SLEEP_US_50);
1856
1857 points.clear();
1858 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, DISPLAY_500);
1859 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, DISPLAY_500);
1860 points.emplace_back(firstPoint);
1861 points.emplace_back(secondPoint);
1862 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_1);
1863 touchExploration_->OnPointerEvent(*event);
1864
1865 usleep(SLEEP_US_50);
1866
1867 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1868
1869 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleMultiFingersContinueDownStateMove_002 end";
1870 }
1871
1872 /**
1873 * @tc.number: HandleTwoFingersUnknownStateDown001
1874 * @tc.name: HandleTwoFingersUnknownStateDown
1875 * @tc.desc: Test func HandleTwoFingersUnknownStateDown.
1876 */
1877 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersUnknownStateDown_001, TestSize.Level0)
1878 {
1879 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateDown_001 start";
1880
1881 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_UNKNOWN);
1882 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
1883 0, 0);
1884 touchExploration_->OnPointerEvent(*event);
1885
1886 usleep(SLEEP_US_50);
1887
1888 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
1889
1890 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateDown_001 end";
1891 }
1892
1893 /**
1894 * @tc.number: HandleTwoFingersUnknownStateDown002
1895 * @tc.name: HandleTwoFingersUnknownStateDown
1896 * @tc.desc: Test func HandleTwoFingersUnknownStateDown.
1897 */
1898 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersUnknownStateDown_002, TestSize.Level0)
1899 {
1900 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateDown_002 start";
1901
1902 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_UNKNOWN);
1903
1904 std::vector<MMI::PointerEvent::PointerItem> points = {};
1905 MMI::PointerEvent::PointerItem firstPoint = {};
1906 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1907 points.emplace_back(firstPoint);
1908 MMI::PointerEvent::PointerItem secondPoint = {};
1909 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1910 points.emplace_back(secondPoint);
1911 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
1912 POINT_ID_1);
1913 touchExploration_->OnPointerEvent(*event);
1914
1915 usleep(SLEEP_US_50);
1916
1917 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_UNKNOWN);
1918
1919 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateDown_002 end";
1920 }
1921
1922 /**
1923 * @tc.number: HandleTwoFingersUnknownStateUp001
1924 * @tc.name: HandleTwoFingersUnknownStateUp
1925 * @tc.desc: Test func HandleTwoFingersUnknownStateUp.
1926 */
1927 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersUnknownStateUp_001, TestSize.Level0)
1928 {
1929 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateUp_001 start";
1930
1931 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_UNKNOWN);
1932 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
1933 0, 0);
1934 touchExploration_->OnPointerEvent(*event);
1935
1936 usleep(SLEEP_US_50);
1937
1938 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TOUCH_INIT);
1939
1940 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateUp_001 end";
1941 }
1942
1943 /**
1944 * @tc.number: HandleTwoFingersUnknownStateUp002
1945 * @tc.name: HandleTwoFingersUnknownStateUp
1946 * @tc.desc: Test func HandleTwoFingersUnknownStateUp.
1947 */
1948 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersUnknownStateUp_002, TestSize.Level0)
1949 {
1950 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateUp_002 start";
1951
1952 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_UNKNOWN);
1953
1954 std::vector<MMI::PointerEvent::PointerItem> points = {};
1955 MMI::PointerEvent::PointerItem firstPoint = {};
1956 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
1957 points.emplace_back(firstPoint);
1958 MMI::PointerEvent::PointerItem secondPoint = {};
1959 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
1960 points.emplace_back(secondPoint);
1961 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
1962 POINT_ID_1);
1963 touchExploration_->OnPointerEvent(*event);
1964
1965 usleep(SLEEP_US_50);
1966
1967 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_UNKNOWN);
1968
1969 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateUp_002 end";
1970 }
1971
1972 /**
1973 * @tc.number: HandleTwoFingersUnknownStateMove001
1974 * @tc.name: HandleTwoFingersUnknownStateMove
1975 * @tc.desc: Test func HandleTwoFingersUnknownStateMove.
1976 */
1977 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleTwoFingersUnknownStateMove_001, TestSize.Level0)
1978 {
1979 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateMove_001 start";
1980
1981 touchExploration_->SetCurrentState(TouchExplorationState::TWO_FINGERS_UNKNOWN);
1982 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, POINT_ID_0,
1983 0, 0);
1984 touchExploration_->OnPointerEvent(*event);
1985
1986 usleep(SLEEP_US_50);
1987
1988 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::TWO_FINGERS_UNKNOWN);
1989
1990 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleTwoFingersUnknownStateMove_001 end";
1991 }
1992
1993 /**
1994 * @tc.number: HandleThreeFingersDownStateDown001
1995 * @tc.name: HandleThreeFingersDownStateDown
1996 * @tc.desc: Test func HandleThreeFingersDownStateDown.
1997 */
1998 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersDownStateDown_001, TestSize.Level0)
1999 {
2000 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateDown_001 start";
2001
2002 touchExploration_->SetCurrentState(TouchExplorationState::THREE_FINGERS_DOWN);
2003 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
2004 0, 0);
2005 touchExploration_->OnPointerEvent(*event);
2006
2007 usleep(SLEEP_US_50);
2008
2009 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
2010
2011 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateDown_001 end";
2012 }
2013
2014 /**
2015 * @tc.number: HandleThreeFingersDownStateDown002
2016 * @tc.name: HandleThreeFingersDownStateDown
2017 * @tc.desc: Test func HandleThreeFingersDownStateDown.
2018 */
2019 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersDownStateDown_002, TestSize.Level0)
2020 {
2021 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateDown_002 start";
2022
2023 touchExploration_->SetCurrentState(TouchExplorationState::THREE_FINGERS_DOWN);
2024
2025 std::vector<MMI::PointerEvent::PointerItem> points = {};
2026 MMI::PointerEvent::PointerItem firstPoint = {};
2027 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
2028 MMI::PointerEvent::PointerItem secondPoint = {};
2029 SetTouchExplorationPoint(secondPoint, POINT_ID_1, 0, 0);
2030 MMI::PointerEvent::PointerItem thirdPoint = {};
2031 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, 0, 0);
2032 MMI::PointerEvent::PointerItem fourthPoint = {};
2033 SetTouchExplorationPoint(fourthPoint, POINT_ID_3, 0, 0);
2034 points.emplace_back(firstPoint);
2035 points.emplace_back(secondPoint);
2036 points.emplace_back(thirdPoint);
2037 points.emplace_back(fourthPoint);
2038 std::shared_ptr<MMI::PointerEvent> event =
2039 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_3);
2040 touchExploration_->OnPointerEvent(*event);
2041
2042 usleep(SLEEP_US_50);
2043
2044 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
2045
2046 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateDown_002 end";
2047 }
2048
2049 /**
2050 * @tc.number: HandleThreeFingersDownStateDown003
2051 * @tc.name: HandleThreeFingersDownStateDown
2052 * @tc.desc: Test func HandleThreeFingersDownStateDown.
2053 */
2054 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersDownStateDown_003, TestSize.Level0)
2055 {
2056 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateDown_003 start";
2057
2058 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
2059 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
2060 0, 0);
2061 touchExploration_->OnPointerEvent(*event);
2062
2063 usleep(SLEEP_US_50);
2064
2065 std::vector<MMI::PointerEvent::PointerItem> points = {};
2066 MMI::PointerEvent::PointerItem firstPoint = {};
2067 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
2068 MMI::PointerEvent::PointerItem secondPoint = {};
2069 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
2070 points.emplace_back(firstPoint);
2071 points.emplace_back(secondPoint);
2072 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
2073 touchExploration_->OnPointerEvent(*event);
2074
2075 usleep(SLEEP_US_50);
2076
2077 MMI::PointerEvent::PointerItem thirdPoint = {};
2078 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, 0, 0);
2079 points.emplace_back(thirdPoint);
2080 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2);
2081 touchExploration_->OnPointerEvent(*event);
2082
2083 usleep(SLEEP_US_50);
2084
2085 MMI::PointerEvent::PointerItem fourthPoint = {};
2086 SetTouchExplorationPoint(fourthPoint, POINT_ID_3, 0, 0);
2087 points.emplace_back(fourthPoint);
2088 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_3);
2089 touchExploration_->OnPointerEvent(*event);
2090
2091 usleep(SLEEP_US_50);
2092
2093 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::FOUR_FINGERS_DOWN);
2094
2095 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateDown_003 end";
2096 }
2097
2098 /**
2099 * @tc.number: HandleThreeFingersDownStateUp001
2100 * @tc.name: HandleThreeFingersDownStateUp
2101 * @tc.desc: Test func HandleThreeFingersDownStateUp.
2102 */
2103 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersDownStateUp_001, TestSize.Level0)
2104 {
2105 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateUp_001 start";
2106
2107 touchExploration_->SetCurrentState(TouchExplorationState::THREE_FINGERS_DOWN);
2108
2109 std::vector<MMI::PointerEvent::PointerItem> points = {};
2110 MMI::PointerEvent::PointerItem firstPoint = {};
2111 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
2112 MMI::PointerEvent::PointerItem secondPoint = {};
2113 SetTouchExplorationPoint(secondPoint, POINT_ID_1, 0, 0);
2114 MMI::PointerEvent::PointerItem thirdPoint = {};
2115 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, 0, 0);
2116 points.emplace_back(firstPoint);
2117 points.emplace_back(secondPoint);
2118 points.emplace_back(thirdPoint);
2119 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
2120 POINT_ID_2);
2121 touchExploration_->OnPointerEvent(*event);
2122
2123 usleep(SLEEP_US_50);
2124
2125 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::THREE_FINGERS_DOWN);
2126
2127 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateUp_001 end";
2128 }
2129
2130 /**
2131 * @tc.number: HandleThreeFingersDownStateUp002
2132 * @tc.name: HandleThreeFingersDownStateUp
2133 * @tc.desc: Test func HandleThreeFingersDownStateUp.
2134 */
2135 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersDownStateUp_002, TestSize.Level0)
2136 {
2137 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateUp_002 start";
2138
2139 touchExploration_->SetCurrentState(TouchExplorationState::THREE_FINGERS_DOWN);
2140 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, POINT_ID_0,
2141 0, 0);
2142 touchExploration_->OnPointerEvent(*event);
2143
2144 usleep(SLEEP_US_50);
2145
2146 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::THREE_FINGERS_TAP);
2147
2148 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateUp_002 end";
2149 }
2150
2151 /**
2152 * @tc.number: HandleThreeFingersDownStateUp003
2153 * @tc.name: HandleThreeFingersDownStateUp
2154 * @tc.desc: Test func HandleThreeFingersDownStateUp.
2155 */
2156 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersDownStateUp_003, TestSize.Level0)
2157 {
2158 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateUp_003 start";
2159
2160 touchExploration_->SetCurrentState(TouchExplorationState::THREE_FINGERS_DOWN);
2161
2162 std::vector<MMI::PointerEvent::PointerItem> points = {};
2163 MMI::PointerEvent::PointerItem firstPoint = {};
2164 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
2165 MMI::PointerEvent::PointerItem secondPoint = {};
2166 SetTouchExplorationPoint(secondPoint, POINT_ID_1, 0, 0);
2167 MMI::PointerEvent::PointerItem thirdPoint = {};
2168 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, 0, 0);
2169 MMI::PointerEvent::PointerItem fourthPoint = {};
2170 SetTouchExplorationPoint(fourthPoint, POINT_ID_3, 0, 0);
2171 points.emplace_back(firstPoint);
2172 points.emplace_back(secondPoint);
2173 points.emplace_back(thirdPoint);
2174 points.emplace_back(fourthPoint);
2175 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points,
2176 POINT_ID_3);
2177 touchExploration_->OnPointerEvent(*event);
2178
2179 usleep(SLEEP_US_50);
2180
2181 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
2182
2183 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateUp_003 end";
2184 }
2185
2186 /**
2187 * @tc.number: HandleThreeFingersDownStateMove001
2188 * @tc.name: HandleThreeFingersDownStateMove
2189 * @tc.desc: Test func HandleThreeFingersDownStateMove.
2190 */
2191 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersDownStateMove_001, TestSize.Level0)
2192 {
2193 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateMove_001 start";
2194
2195 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
2196
2197 std::vector<MMI::PointerEvent::PointerItem> points = {};
2198 MMI::PointerEvent::PointerItem firstPoint = {};
2199 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
2200 points.emplace_back(firstPoint);
2201 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
2202 POINT_ID_0);
2203 touchExploration_->OnPointerEvent(*event);
2204
2205 usleep(SLEEP_US_50);
2206
2207 MMI::PointerEvent::PointerItem secondPoint = {};
2208 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
2209 points.emplace_back(secondPoint);
2210 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
2211 touchExploration_->OnPointerEvent(*event);
2212
2213 usleep(SLEEP_US_50);
2214
2215 MMI::PointerEvent::PointerItem thirdPoint = {};
2216 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, DISPLAY_10 + DISPLAY_10, 0);
2217 points.emplace_back(thirdPoint);
2218 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2);
2219 touchExploration_->OnPointerEvent(*event);
2220
2221 usleep(SLEEP_US_50);
2222
2223 points.clear();
2224 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, DISPLAY_500);
2225 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, DISPLAY_500);
2226 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, DISPLAY_10 + DISPLAY_10, DISPLAY_500);
2227 points.emplace_back(firstPoint);
2228 points.emplace_back(secondPoint);
2229 points.emplace_back(thirdPoint);
2230 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_2);
2231 touchExploration_->OnPointerEvent(*event);
2232
2233 usleep(SLEEP_US_50);
2234
2235 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::THREE_FINGERS_SWIPE);
2236
2237 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateMove_001 end";
2238 }
2239
2240 /**
2241 * @tc.number: HandleThreeFingersDownStateMove002
2242 * @tc.name: HandleThreeFingersDownStateMove
2243 * @tc.desc: Test func HandleThreeFingersDownStateMove.
2244 */
2245 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersDownStateMove_002, TestSize.Level0)
2246 {
2247 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateMove_002 start";
2248
2249 touchExploration_->SetCurrentState(TouchExplorationState::TOUCH_INIT);
2250
2251 std::vector<MMI::PointerEvent::PointerItem> points = {};
2252 MMI::PointerEvent::PointerItem firstPoint = {};
2253 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, 0);
2254 points.emplace_back(firstPoint);
2255 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points,
2256 POINT_ID_0);
2257 touchExploration_->OnPointerEvent(*event);
2258
2259 usleep(SLEEP_US_50);
2260
2261 MMI::PointerEvent::PointerItem secondPoint = {};
2262 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, 0);
2263 points.emplace_back(secondPoint);
2264 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1);
2265 touchExploration_->OnPointerEvent(*event);
2266
2267 usleep(SLEEP_US_50);
2268
2269 MMI::PointerEvent::PointerItem thirdPoint = {};
2270 SetTouchExplorationPoint(thirdPoint, POINT_ID_2, DISPLAY_10 + DISPLAY_10, 0);
2271 points.emplace_back(thirdPoint);
2272 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2);
2273 touchExploration_->OnPointerEvent(*event);
2274
2275 usleep(SLEEP_US_50);
2276
2277 points.clear();
2278 SetTouchExplorationPoint(firstPoint, POINT_ID_0, 0, DISPLAY_500);
2279 SetTouchExplorationPoint(secondPoint, POINT_ID_1, DISPLAY_10, DISPLAY_500);
2280 points.emplace_back(firstPoint);
2281 points.emplace_back(secondPoint);
2282 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_1);
2283 touchExploration_->OnPointerEvent(*event);
2284
2285 usleep(SLEEP_US_50);
2286
2287 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
2288
2289 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersDownStateMove_002 end";
2290 }
2291
2292 /**
2293 * @tc.number: HandleThreeFingersSwipeStateDown001
2294 * @tc.name: HandleThreeFingersSwipeStateDown
2295 * @tc.desc: Test func HandleThreeFingersSwipeStateDown.
2296 */
2297 HWTEST_F(TouchExplorationTest, TouchExploration_Unittest_HandleThreeFingersSwipeStateDown_001, TestSize.Level0)
2298 {
2299 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersSwipeStateDown_001 start";
2300
2301 touchExploration_->SetCurrentState(TouchExplorationState::THREE_FINGERS_SWIPE);
2302 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, POINT_ID_0,
2303 0, 0);
2304 touchExploration_->OnPointerEvent(*event);
2305
2306 usleep(SLEEP_US_50);
2307
2308 EXPECT_EQ(touchExploration_->GetCurrentState(), TouchExplorationState::INVALID);
2309
2310 GTEST_LOG_(INFO) << "TouchExploration_Unittest_HandleThreeFingersSwipeStateDown_001 end";
2311 }
2312 } // namespace Accessibility
2313 } // namespace OHOS