1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "accessibility_touch_guider.h"
18
19 using namespace std;
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Accessibility {
25 extern std::vector<int> g_touchAction;
26 extern std::vector<EventType> g_eventType;
27 extern int g_uTgestureId;
28 extern bool g_isClearEvents;
29 extern bool g_isDestroyEvents;
30 class TouchGuiderTest : public testing::Test {
31 public:
TouchGuiderTest()32 TouchGuiderTest() {}
~TouchGuiderTest()33 ~TouchGuiderTest() {}
34
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 protected:
40 std::shared_ptr<MMI::PointerEvent> CreateTouchEvent(int action);
41 std::shared_ptr<MMI::PointerEvent> CreateTouchEvent(int action,
42 std::vector<MMI::PointerEvent::PointerItem> points,
43 int pointerCount, unsigned int occurredTime, unsigned int startTime);
44 std::shared_ptr<MMI::PointerEvent> CreateMoveEvent(int pointerCount);
45 std::unique_ptr<TouchGuider> touchGuider_ = nullptr;
46 int pointId_ = -1;
47 };
48
SetUpTestCase()49 void TouchGuiderTest::SetUpTestCase()
50 {
51 GTEST_LOG_(INFO) << "TouchGuiderTest SetUpTestCase";
52 DelayedSingleton<AccessibleAbilityManagerService>::GetInstance()->OnStart();
53 }
54
TearDownTestCase()55 void TouchGuiderTest::TearDownTestCase()
56 {
57 GTEST_LOG_(INFO) << "TouchGuiderTest TearDownTestCase";
58 }
59
SetUp()60 void TouchGuiderTest::SetUp()
61 {
62 GTEST_LOG_(INFO) << "TouchGuiderTest SetUp";
63
64 touchGuider_ = std::make_unique<TouchGuider>();
65 if (!touchGuider_) {
66 GTEST_LOG_(INFO) << "touchGuider new failed!";
67 return;
68 }
69 touchGuider_->StartUp();
70 pointId_ = 0;
71 }
72
TearDown()73 void TouchGuiderTest::TearDown()
74 {
75 GTEST_LOG_(INFO) << "TouchGuiderTest TearDown";
76 g_eventType.clear();
77 g_touchAction.clear();
78 }
79
CreateTouchEvent(int action)80 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateTouchEvent(int action)
81 {
82 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
83 MMI::PointerEvent::PointerItem item = {};
84
85 pointerEvent->AddPointerItem(item);
86 pointerEvent->SetPointerId(pointId_++);
87 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
88 pointerEvent->SetPointerAction(action);
89
90 return pointerEvent;
91 }
92
CreateTouchEvent(int action,std::vector<MMI::PointerEvent::PointerItem> points,int pointerId,unsigned int occurredTime,unsigned int startTime)93 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateTouchEvent(int action,
94 std::vector<MMI::PointerEvent::PointerItem> points, int pointerId,
95 unsigned int occurredTime, unsigned int startTime)
96 {
97 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
98
99 for (auto point : points) {
100 pointerEvent->AddPointerItem(point);
101 }
102 pointerEvent->SetPointerId(pointerId);
103 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
104 pointerEvent->SetPointerAction(action);
105 pointerEvent->SetActionStartTime(startTime);
106 pointerEvent->SetActionTime(occurredTime);
107
108 return pointerEvent;
109 }
110
CreateMoveEvent(int pointerCount)111 std::shared_ptr<MMI::PointerEvent> TouchGuiderTest::CreateMoveEvent(int pointerCount)
112 {
113 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
114 MMI::PointerEvent::PointerItem item = {};
115
116 pointerEvent->AddPointerItem(item);
117 pointerEvent->SetPointerId(pointId_++);
118 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
119 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
120
121 return pointerEvent;
122 }
123
124 /**
125 * @tc.number: OnTouchEvent001
126 * @tc.name: OnPointerEvent
127 * @tc.desc: Check the first down event.
128 */
129 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_001, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_001 start";
132
133 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
134 touchGuider_->OnPointerEvent(*event);
135 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
136
137 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_001 end";
138 }
139
140 /**
141 * @tc.number: OnTouchEvent002
142 * @tc.name: OnPointerEvent
143 * @tc.desc: Check the first up event.
144 */
145 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_002, TestSize.Level1)
146 {
147 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_002 start";
148
149 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
150 touchGuider_->OnPointerEvent(*event);
151 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
152
153 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
154 touchGuider_->OnPointerEvent(*event);
155
156 sleep(3);
157 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_BEGIN);
158 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
159 EXPECT_EQ(g_touchAction[0], expectValue);
160 EXPECT_EQ(g_touchAction[1], expectValue);
161 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_END);
162 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
163
164 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_002 end";
165 }
166
167 /**
168 * @tc.number: OnTouchEvent003
169 * @tc.name: OnPointerEvent
170 * @tc.desc: Check the event that down-up slowly.
171 */
172 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_003, TestSize.Level1)
173 {
174 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_003 start";
175
176 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
177 touchGuider_->OnPointerEvent(*event);
178 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
179
180 sleep(1);
181 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_BEGIN);
182 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
183 EXPECT_EQ(g_touchAction[0], expectValue);
184
185 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
186 touchGuider_->OnPointerEvent(*event);
187
188 sleep(3);
189
190 EXPECT_EQ(g_touchAction[1], expectValue);
191 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_END);
192 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
193
194 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_003 end";
195 }
196
197 /**
198 * @tc.number: OnTouchEvent004
199 * @tc.name: OnPointerEvent
200 * @tc.desc: Check the event that move slowly with one finger.
201 */
202 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_004, TestSize.Level1)
203 {
204 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_004 start";
205
206 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
207 touchGuider_->OnPointerEvent(*event);
208 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
209
210 sleep(1);
211 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_BEGIN);
212 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
213 EXPECT_EQ(g_touchAction[0], expectValue);
214
215 event = CreateMoveEvent(1);
216 touchGuider_->OnPointerEvent(*event);
217 EXPECT_EQ(g_touchAction[1], expectValue);
218
219 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
220 touchGuider_->OnPointerEvent(*event);
221 sleep(3);
222
223 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_END);
224 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
225
226 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_004 end";
227 }
228
229 /**
230 * @tc.number: OnTouchEvent006
231 * @tc.name: OnPointerEvent
232 * @tc.desc: Check the event that two fingers moving in same directions in touchGuiding state.
233 */
234 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_006, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_006 start";
237
238 std::vector<MMI::PointerEvent::PointerItem> points = {};
239 MMI::PointerEvent::PointerItem point = {};
240 point.SetPointerId(1);
241 MMI::PointerEvent::PointerItem otherPoint = {};
242 otherPoint.SetPointerId(2);
243 otherPoint.SetGlobalX(10);
244 otherPoint.SetGlobalY(10);
245
246 points.emplace_back(point);
247 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN,
248 points, 1, 0, 0);
249 touchGuider_->OnPointerEvent(*event);
250 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
251
252 points.emplace_back(otherPoint);
253 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
254 touchGuider_->OnPointerEvent(*event);
255
256 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
257 touchGuider_->OnPointerEvent(*event);
258 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
259 EXPECT_EQ(g_touchAction[0], expectValue);
260
261 points.clear();
262 points.emplace_back(otherPoint);
263 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 2, 0, 0);
264 touchGuider_->OnPointerEvent(*event);
265
266 points.clear();
267 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
268 touchGuider_->OnPointerEvent(*event);
269 expectValue = MMI::PointerEvent::POINTER_ACTION_UP;
270 EXPECT_EQ(g_touchAction[1], expectValue);
271 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_END);
272
273 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_006 end";
274 }
275
276 /**
277 * @tc.number: OnTouchEvent007
278 * @tc.name: OnPointerEvent
279 * @tc.desc: Check the event that multi-finger gesture.
280 */
281 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_007, TestSize.Level1)
282 {
283 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_007 start";
284
285 std::vector<MMI::PointerEvent::PointerItem> points = {};
286 MMI::PointerEvent::PointerItem point = {};
287 point.SetPointerId(1);
288 MMI::PointerEvent::PointerItem otherPoint = {};
289 otherPoint.SetPointerId(2);
290 otherPoint.SetGlobalX(10);
291 otherPoint.SetGlobalY(10);
292 MMI::PointerEvent::PointerItem otherPoint1 = {};
293 otherPoint1.SetPointerId(3);
294 otherPoint1.SetGlobalX(10);
295 otherPoint1.SetGlobalY(10);
296
297 points.emplace_back(point);
298 std::shared_ptr<MMI::PointerEvent> event =
299 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
300 touchGuider_->OnPointerEvent(*event);
301 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
302
303 points.emplace_back(otherPoint);
304 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
305 touchGuider_->OnPointerEvent(*event);
306
307 points.emplace_back(otherPoint1);
308 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 3, 0, 0);
309 touchGuider_->OnPointerEvent(*event);
310
311 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 3, 0, 0);
312 touchGuider_->OnPointerEvent(*event);
313 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
314 EXPECT_EQ(g_touchAction[0], expectValue);
315
316 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_007 end";
317 }
318
319 /**
320 * @tc.number: OnTouchEvent008
321 * @tc.name: OnPointerEvent
322 * @tc.desc: Check the CANCEL event.
323 */
324 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_008, TestSize.Level1)
325 {
326 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_008 start";
327
328 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
329 touchGuider_->OnPointerEvent(*event);
330 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
331
332 sleep(1);
333 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_BEGIN);
334 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
335 EXPECT_EQ(g_touchAction[0], expectValue);
336 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_CANCEL);
337 touchGuider_->OnPointerEvent(*event);
338
339 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_008 end";
340 }
341
342 /**
343 * @tc.number: OnTouchEvent009
344 * @tc.name: OnPointerEvent
345 * @tc.desc: Check the OTHER_POINT_DOWN event in draging state.
346 */
347 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_009, TestSize.Level1)
348 {
349 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_009 start";
350
351 std::vector<MMI::PointerEvent::PointerItem> points = {};
352 MMI::PointerEvent::PointerItem point = {};
353 point.SetPointerId(1);
354 MMI::PointerEvent::PointerItem otherPoint = {};
355 otherPoint.SetPointerId(2);
356 otherPoint.SetGlobalX(500);
357 otherPoint.SetGlobalY(500);
358 MMI::PointerEvent::PointerItem otherPoint1 = {};
359 otherPoint1.SetPointerId(3);
360 otherPoint1.SetGlobalX(500);
361 otherPoint1.SetGlobalY(500);
362
363 points.emplace_back(point);
364 std::shared_ptr<MMI::PointerEvent> event =
365 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
366 touchGuider_->OnPointerEvent(*event);
367 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
368
369 points.emplace_back(otherPoint);
370 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
371 touchGuider_->OnPointerEvent(*event);
372
373 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
374 touchGuider_->OnPointerEvent(*event);
375 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
376 EXPECT_EQ(g_touchAction[0], expectValue);
377
378 points.emplace_back(otherPoint1);
379 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 3, 0, 0);
380 touchGuider_->OnPointerEvent(*event);
381 expectValue = MMI::PointerEvent::POINTER_ACTION_UP;
382 EXPECT_EQ(g_touchAction[1], expectValue);
383 expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
384 EXPECT_EQ(g_touchAction[2], expectValue);
385
386 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_009 end";
387 }
388
389 /**
390 * @tc.number: OnTouchEvent010
391 * @tc.name: OnPointerEvent
392 * @tc.desc: Check the event that two fingers moving in sanme directions in draging state.
393 */
394 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_010, TestSize.Level1)
395 {
396 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_010 start";
397
398 std::vector<MMI::PointerEvent::PointerItem> points = {};
399 MMI::PointerEvent::PointerItem point = {};
400 point.SetPointerId(1);
401 MMI::PointerEvent::PointerItem otherPoint = {};
402 otherPoint.SetPointerId(2);
403 otherPoint.SetGlobalX(10);
404 otherPoint.SetGlobalY(10);
405
406 points.emplace_back(point);
407 std::shared_ptr<MMI::PointerEvent> event =
408 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
409 touchGuider_->OnPointerEvent(*event);
410 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
411
412 points.emplace_back(otherPoint);
413 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
414 touchGuider_->OnPointerEvent(*event);
415
416 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
417 touchGuider_->OnPointerEvent(*event);
418 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
419 EXPECT_EQ(g_touchAction[0], expectValue);
420
421 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
422 touchGuider_->OnPointerEvent(*event);
423 expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
424 EXPECT_EQ(g_touchAction[1], expectValue);
425
426 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_010 end";
427 }
428
429 /**
430 * @tc.number: OnTouchEvent011
431 * @tc.name: OnPointerEvent
432 * @tc.desc: Check the event that multi-finger moving in draging state.
433 */
434 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_011, TestSize.Level1)
435 {
436 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_011 start";
437
438 std::vector<MMI::PointerEvent::PointerItem> points = {};
439 MMI::PointerEvent::PointerItem point = {};
440 point.SetPointerId(1);
441 MMI::PointerEvent::PointerItem otherPoint = {};
442 otherPoint.SetPointerId(2);
443 otherPoint.SetGlobalX(500);
444 otherPoint.SetGlobalY(500);
445 MMI::PointerEvent::PointerItem otherPoint1 = {};
446 otherPoint1.SetPointerId(3);
447 otherPoint1.SetGlobalX(500);
448 otherPoint1.SetGlobalY(500);
449
450 points.emplace_back(point);
451 std::shared_ptr<MMI::PointerEvent> event =
452 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
453 touchGuider_->OnPointerEvent(*event);
454 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
455
456 points.emplace_back(otherPoint);
457 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
458 touchGuider_->OnPointerEvent(*event);
459
460 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
461 touchGuider_->OnPointerEvent(*event);
462 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
463 EXPECT_EQ(g_touchAction[0], expectValue);
464
465 points.emplace_back(otherPoint1);
466 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 3, 0, 0);
467 touchGuider_->OnPointerEvent(*event);
468
469 expectValue = MMI::PointerEvent::POINTER_ACTION_UP;
470 EXPECT_EQ(g_touchAction[1], expectValue);
471 expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
472 EXPECT_EQ(g_touchAction[2], expectValue);
473
474 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_011 end";
475 }
476
477 /**
478 * @tc.number: OnTouchEvent012
479 * @tc.name: OnPointerEvent
480 * @tc.desc: Check the drag event .
481 */
482 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_012, TestSize.Level1)
483 {
484 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_012 start";
485
486 std::vector<MMI::PointerEvent::PointerItem> points = {};
487 MMI::PointerEvent::PointerItem point = {};
488 point.SetPointerId(1);
489 point.SetGlobalX(10);
490 point.SetGlobalY(10);
491 MMI::PointerEvent::PointerItem otherPoint = {};
492 otherPoint.SetPointerId(2);
493 otherPoint.SetGlobalX(50);
494 otherPoint.SetGlobalY(10);
495
496 points.emplace_back(point);
497 std::shared_ptr<MMI::PointerEvent> event =
498 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
499 touchGuider_->OnPointerEvent(*event);
500 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
501
502 points.emplace_back(otherPoint);
503 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
504 touchGuider_->OnPointerEvent(*event);
505
506 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0);
507 touchGuider_->OnPointerEvent(*event);
508 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
509 EXPECT_EQ(g_touchAction[0], expectValue);
510
511 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_012 end";
512 }
513
514 /**
515 * @tc.number: OnTouchEvent013
516 * @tc.name: OnPointerEvent
517 * @tc.desc: Check the accessibility event.
518 */
519 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_013, TestSize.Level1)
520 {
521 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_013 start";
522
523 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
524 touchGuider_->OnPointerEvent(*event);
525 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
526
527 sleep(1);
528 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_BEGIN);
529 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
530 EXPECT_EQ(g_touchAction[0], expectValue);
531
532 event = CreateMoveEvent(1);
533 touchGuider_->OnPointerEvent(*event);
534 EXPECT_EQ(g_touchAction[1], expectValue);
535
536 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
537 touchGuider_->OnPointerEvent(*event);
538
539 AccessibilityEventInfo accessibilityEvent;
540 accessibilityEvent.SetEventType(EventType::TYPE_VIEW_HOVER_EXIT_EVENT);
541 touchGuider_->OnAccessibilityEvent(accessibilityEvent);
542
543 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_END);
544 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
545
546 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_013 end";
547 }
548
549 /**
550 * @tc.number: OnTouchEvent014
551 * @tc.name: OnPointerEvent
552 * @tc.desc: Check cancel the second move event after onstart.
553 */
554 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_014, TestSize.Level1)
555 {
556 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_014 start";
557
558 std::vector<MMI::PointerEvent::PointerItem> points = {};
559 MMI::PointerEvent::PointerItem point = {};
560 point.SetPointerId(1);
561 point.SetGlobalX(500);
562 point.SetGlobalY(500);
563 MMI::PointerEvent::PointerItem movepoint = {};
564 movepoint.SetPointerId(1);
565 movepoint.SetGlobalX(2500);
566 movepoint.SetGlobalY(500);
567 MMI::PointerEvent::PointerItem othermovepoint = {};
568 othermovepoint.SetPointerId(1);
569 othermovepoint.SetGlobalX(2500);
570 othermovepoint.SetGlobalY(750);
571
572 points.emplace_back(point);
573 std::shared_ptr<MMI::PointerEvent> event =
574 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
575 touchGuider_->OnPointerEvent(*event);
576 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
577
578 points.clear();
579 points.emplace_back(movepoint);
580 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
581 touchGuider_->OnPointerEvent(*event);
582 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
583 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
584 EXPECT_EQ(g_touchAction[0], expectValue);
585
586 points.clear();
587 points.emplace_back(othermovepoint);
588 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 400, 0);
589 touchGuider_->OnPointerEvent(*event);
590 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
591
592 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_014 end";
593 }
594
595 /**
596 * @tc.number: OnTouchEvent015
597 * @tc.name: OnPointerEvent
598 * @tc.desc: Check the RIGHT_THEN_DOWN gesture.
599 */
600 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_015, TestSize.Level1)
601 {
602 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_015 start";
603
604 std::vector<MMI::PointerEvent::PointerItem> points = {};
605 MMI::PointerEvent::PointerItem point = {};
606 point.SetPointerId(1);
607 point.SetGlobalX(2500);
608 point.SetGlobalY(2500);
609 MMI::PointerEvent::PointerItem movepoint1 = {};
610 movepoint1.SetPointerId(1);
611 movepoint1.SetGlobalX(3500);
612 movepoint1.SetGlobalY(2500);
613 MMI::PointerEvent::PointerItem movepoint2 = {};
614 movepoint2.SetPointerId(1);
615 movepoint2.SetGlobalX(5000);
616 movepoint2.SetGlobalY(2500);
617 MMI::PointerEvent::PointerItem movepoint3 = {};
618 movepoint3.SetPointerId(1);
619 movepoint3.SetGlobalX(4000);
620 movepoint3.SetGlobalY(0);
621
622 points.emplace_back(point);
623 std::shared_ptr<MMI::PointerEvent> event =
624 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
625 touchGuider_->OnPointerEvent(*event);
626 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
627
628 points.clear();
629 points.emplace_back(movepoint1);
630 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
631 touchGuider_->OnPointerEvent(*event);
632 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
633 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
634 EXPECT_EQ(g_touchAction[0], expectValue);
635
636 points.clear();
637 points.emplace_back(movepoint2);
638 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
639 touchGuider_->OnPointerEvent(*event);
640 EXPECT_EQ(g_touchAction[1], expectValue);
641
642 points.clear();
643 points.emplace_back(movepoint3);
644 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
645 touchGuider_->OnPointerEvent(*event);
646 EXPECT_EQ(g_touchAction[2], expectValue);
647
648 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
649 touchGuider_->OnPointerEvent(*event);
650
651 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
652 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
653 EXPECT_EQ(g_uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_RIGHT_THEN_DOWN));
654
655 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_015 end";
656 }
657
658 /**
659 * @tc.number: OnTouchEvent016
660 * @tc.name: OnPointerEvent
661 * @tc.desc: Check the LEFT_THEN_DOWN gesture.
662 */
663 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_016, TestSize.Level1)
664 {
665 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_016 start";
666
667 std::vector<MMI::PointerEvent::PointerItem> points = {};
668 MMI::PointerEvent::PointerItem point = {};
669 point.SetPointerId(1);
670 point.SetGlobalX(2500);
671 point.SetGlobalY(2500);
672 MMI::PointerEvent::PointerItem movepoint1 = {};
673 movepoint1.SetPointerId(1);
674 movepoint1.SetGlobalX(1500);
675 movepoint1.SetGlobalY(2500);
676 MMI::PointerEvent::PointerItem movepoint2 = {};
677 movepoint2.SetPointerId(1);
678 movepoint2.SetGlobalX(0);
679 movepoint2.SetGlobalY(2500);
680 MMI::PointerEvent::PointerItem movepoint3 = {};
681 movepoint3.SetPointerId(1);
682 movepoint3.SetGlobalX(1000);
683 movepoint3.SetGlobalY(0);
684
685 points.emplace_back(point);
686 std::shared_ptr<MMI::PointerEvent> event =
687 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
688 touchGuider_->OnPointerEvent(*event);
689 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
690
691 points.clear();
692 points.emplace_back(movepoint1);
693 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
694 touchGuider_->OnPointerEvent(*event);
695 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
696 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
697 EXPECT_EQ(g_touchAction[0], expectValue);
698
699 points.clear();
700 points.emplace_back(movepoint2);
701 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
702 touchGuider_->OnPointerEvent(*event);
703 EXPECT_EQ(g_touchAction[1], expectValue);
704
705 points.clear();
706 points.emplace_back(movepoint3);
707 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
708 touchGuider_->OnPointerEvent(*event);
709 EXPECT_EQ(g_touchAction[2], expectValue);
710
711 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
712 touchGuider_->OnPointerEvent(*event);
713
714 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
715 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
716 EXPECT_EQ(g_uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_LEFT_THEN_DOWN));
717
718 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_016 end";
719 }
720
721 /**
722 * @tc.number: OnTouchEvent017
723 * @tc.name: OnPointerEvent
724 * @tc.desc: Check the UP_THEN_LEFT gesture.
725 */
726 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_017, TestSize.Level1)
727 {
728 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_017 start";
729
730 std::vector<MMI::PointerEvent::PointerItem> points = {};
731 MMI::PointerEvent::PointerItem point = {};
732 point.SetPointerId(1);
733 point.SetGlobalX(2500);
734 point.SetGlobalY(2500);
735 MMI::PointerEvent::PointerItem movepoint1 = {};
736 movepoint1.SetPointerId(1);
737 movepoint1.SetGlobalX(2500);
738 movepoint1.SetGlobalY(3500);
739 MMI::PointerEvent::PointerItem movepoint2 = {};
740 movepoint2.SetPointerId(1);
741 movepoint2.SetGlobalX(2500);
742 movepoint2.SetGlobalY(5000);
743 MMI::PointerEvent::PointerItem movepoint3 = {};
744 movepoint3.SetPointerId(1);
745 movepoint3.SetGlobalX(0);
746 movepoint3.SetGlobalY(4000);
747
748 points.emplace_back(point);
749 std::shared_ptr<MMI::PointerEvent> event =
750 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
751 touchGuider_->OnPointerEvent(*event);
752 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
753
754 points.clear();
755 points.emplace_back(movepoint1);
756 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
757 touchGuider_->OnPointerEvent(*event);
758 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
759 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
760 EXPECT_EQ(g_touchAction[0], expectValue);
761
762 points.clear();
763 points.emplace_back(movepoint2);
764 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
765 touchGuider_->OnPointerEvent(*event);
766 EXPECT_EQ(g_touchAction[1], expectValue);
767
768 points.clear();
769 points.emplace_back(movepoint3);
770 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
771 touchGuider_->OnPointerEvent(*event);
772 EXPECT_EQ(g_touchAction[2], expectValue);
773
774 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
775 touchGuider_->OnPointerEvent(*event);
776
777 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
778 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
779 EXPECT_EQ(g_uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_UP_THEN_LEFT));
780
781 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_017 end";
782 }
783
784 /**
785 * @tc.number: OnTouchEvent018
786 * @tc.name: OnPointerEvent
787 * @tc.desc: Check the UP_THEN_RIGHT gesture.
788 */
789 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_018, TestSize.Level1)
790 {
791 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_018 start";
792
793 std::vector<MMI::PointerEvent::PointerItem> points = {};
794 MMI::PointerEvent::PointerItem point = {};
795 point.SetPointerId(1);
796 point.SetGlobalX(2500);
797 point.SetGlobalY(2500);
798 MMI::PointerEvent::PointerItem movepoint1 = {};
799 movepoint1.SetPointerId(1);
800 movepoint1.SetGlobalX(2500);
801 movepoint1.SetGlobalY(3500);
802 MMI::PointerEvent::PointerItem movepoint2 = {};
803 movepoint2.SetPointerId(1);
804 movepoint2.SetGlobalX(2500);
805 movepoint2.SetGlobalY(5000);
806 MMI::PointerEvent::PointerItem movepoint3 = {};
807 movepoint3.SetPointerId(1);
808 movepoint3.SetGlobalX(5000);
809 movepoint3.SetGlobalY(4000);
810
811 points.emplace_back(point);
812 std::shared_ptr<MMI::PointerEvent> event =
813 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
814 touchGuider_->OnPointerEvent(*event);
815 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
816
817 points.clear();
818 points.emplace_back(movepoint1);
819 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
820 touchGuider_->OnPointerEvent(*event);
821 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
822 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
823 EXPECT_EQ(g_touchAction[0], expectValue);
824
825 points.clear();
826 points.emplace_back(movepoint2);
827 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
828 touchGuider_->OnPointerEvent(*event);
829 EXPECT_EQ(g_touchAction[1], expectValue);
830
831 points.clear();
832 points.emplace_back(movepoint3);
833 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
834 touchGuider_->OnPointerEvent(*event);
835 EXPECT_EQ(g_touchAction[2], expectValue);
836
837 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
838 touchGuider_->OnPointerEvent(*event);
839
840 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
841 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
842 EXPECT_EQ(g_uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_UP_THEN_RIGHT));
843
844 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_018 end";
845 }
846
847 /**
848 * @tc.number: OnTouchEvent019
849 * @tc.name: OnPointerEvent
850 * @tc.desc: Check the LEFT gesture.
851 */
852 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_019, TestSize.Level1)
853 {
854 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_019 start";
855
856 std::vector<MMI::PointerEvent::PointerItem> points = {};
857 MMI::PointerEvent::PointerItem point = {};
858 point.SetPointerId(1);
859 point.SetGlobalX(2500);
860 point.SetGlobalY(2500);
861 MMI::PointerEvent::PointerItem movepoint1 = {};
862 movepoint1.SetPointerId(1);
863 movepoint1.SetGlobalX(1000);
864 movepoint1.SetGlobalY(2500);
865 MMI::PointerEvent::PointerItem movepoint2 = {};
866 movepoint2.SetPointerId(1);
867 movepoint2.SetGlobalX(0);
868 movepoint2.SetGlobalY(2500);
869
870 points.emplace_back(point);
871 std::shared_ptr<MMI::PointerEvent> event =
872 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
873 touchGuider_->OnPointerEvent(*event);
874 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
875
876 points.clear();
877 points.emplace_back(movepoint1);
878 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
879 touchGuider_->OnPointerEvent(*event);
880 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN);
881 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
882 EXPECT_EQ(g_touchAction[0], expectValue);
883
884 points.clear();
885 points.emplace_back(movepoint2);
886 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 0, 0);
887 touchGuider_->OnPointerEvent(*event);
888 EXPECT_EQ(g_touchAction[1], expectValue);
889
890 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0);
891 touchGuider_->OnPointerEvent(*event);
892
893 EXPECT_EQ(g_eventType[2], EventType::TYPE_TOUCH_GUIDE_GESTURE_END);
894 EXPECT_EQ(g_eventType[3], EventType::TYPE_TOUCH_END);
895 EXPECT_EQ(g_uTgestureId, static_cast<int>(GestureType::GESTURE_SWIPE_LEFT));
896
897 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_019 end";
898 }
899
900 /**
901 * @tc.number: OnTouchEvent020
902 * @tc.name: OnPointerEvent
903 * @tc.desc: Check cancel the first move event without onstart.
904 */
905 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_020, TestSize.Level1)
906 {
907 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_020 start";
908
909 std::vector<MMI::PointerEvent::PointerItem> points = {};
910 MMI::PointerEvent::PointerItem point = {};
911 point.SetPointerId(1);
912 point.SetGlobalX(2500);
913 point.SetGlobalY(2500);
914 MMI::PointerEvent::PointerItem movepoint1 = {};
915 movepoint1.SetPointerId(1);
916 movepoint1.SetGlobalX(2250);
917 movepoint1.SetGlobalY(2500);
918
919 points.emplace_back(point);
920 std::shared_ptr<MMI::PointerEvent> event =
921 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
922 touchGuider_->OnPointerEvent(*event);
923 EXPECT_EQ(g_eventType[0], EventType::TYPE_TOUCH_BEGIN);
924
925 points.clear();
926 points.emplace_back(movepoint1);
927 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 1, 400, 0);
928 touchGuider_->OnPointerEvent(*event);
929 EXPECT_EQ(g_eventType[1], EventType::TYPE_TOUCH_GUIDE_BEGIN);
930 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
931 EXPECT_EQ(g_touchAction[0], expectValue);
932 EXPECT_EQ(g_touchAction[1], expectValue);
933
934 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_020 end";
935 }
936
937 /**
938 * @tc.number: OnTouchEvent023
939 * @tc.name: OnPointerEvent
940 * @tc.desc: Check ClearEvents and DestroyEvents.
941 */
942 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnTouchEvent_023, TestSize.Level1)
943 {
944 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_023 start";
945
946 touchGuider_->ClearEvents(MMI::PointerEvent::SOURCE_TYPE_TOUCHPAD);
947 EXPECT_EQ(g_isClearEvents, true);
948
949 touchGuider_->DestroyEvents();
950 EXPECT_EQ(g_isDestroyEvents, true);
951
952 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnTouchEvent_023 end";
953 }
954 } // namespace Accessibility
955 } // namespace OHOS