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 #include "gtest/gtest.h"
16 #include "test/unittest/core/gestures/gestures_common_test_ng.h"
17
18 using namespace testing;
19 using namespace testing::ext;
20
21 namespace OHOS::Ace::NG {
22 class GestureGroupTestNg : public GesturesCommonTestNg {
23 public:
24 static void SetUpTestSuite();
25 static void TearDownTestSuite();
26 };
27
SetUpTestSuite()28 void GestureGroupTestNg::SetUpTestSuite()
29 {
30 MockPipelineContext::SetUp();
31 }
32
TearDownTestSuite()33 void GestureGroupTestNg::TearDownTestSuite()
34 {
35 MockPipelineContext::TearDown();
36 }
37
38 /**
39 * @tc.name: RecognizerGroupTest001
40 * @tc.desc: Test RecognizerGroup function: OnBeginGestureReferee
41 * @tc.type: FUNC
42 */
43 HWTEST_F(GestureGroupTestNg, RecognizerGroupTest001, TestSize.Level1)
44 {
45 /**
46 * @tc.steps: step1. create RecognizerGroup
47 */
48 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
49 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
50 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
51
52 /**
53 * @tc.steps: step2. call OnBeginGestureReferee function and compare result.
54 * @tc.steps: case1: needUpdateChild is false
55 * @tc.expected: step2. result equals.
56 */
57 exclusiveRecognizer->recognizers_.clear();
58 exclusiveRecognizer->OnBeginGestureReferee(0, false);
59 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
60
61 /**
62 * @tc.steps: step2. call OnBeginGestureReferee function and compare result.
63 * @tc.steps: case2: needUpdateChild is true, recognizers is empty
64 * @tc.expected: step2. result equals.
65 */
66 exclusiveRecognizer->recognizers_.clear();
67 exclusiveRecognizer->OnBeginGestureReferee(0, true);
68 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
69
70 /**
71 * @tc.steps: step2. call OnBeginGestureReferee function and compare result.
72 * @tc.steps: case3: needUpdateChild is true, recognizers has nullptr
73 * @tc.expected: step2. result equals.
74 */
75 exclusiveRecognizer->recognizers_.clear();
76 exclusiveRecognizer->recognizers_.push_back(nullptr);
77 exclusiveRecognizer->OnBeginGestureReferee(0, true);
78 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
79
80 /**
81 * @tc.steps: step2. call OnBeginGestureReferee function and compare result.
82 * @tc.steps: case4: needUpdateChild is true, recognizers has ptr
83 * @tc.expected: step2. result equals.
84 */
85 exclusiveRecognizer->recognizers_.clear();
86 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
87 exclusiveRecognizer->OnBeginGestureReferee(0, true);
88 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
89 }
90
91 /**
92 * @tc.name: RecognizerGroupCheckStatesTest001
93 * @tc.desc: Test RecognizerGroup function: CheckStates
94 * @tc.type: FUNC
95 */
96 HWTEST_F(GestureGroupTestNg, RecognizerGroupCheckStatesTest001, TestSize.Level1)
97 {
98 /**
99 * @tc.steps: step1. create RecognizerGroup
100 */
101 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
102 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
103 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
104
105 /**
106 * @tc.steps: step2. call CheckStates function and compare result.
107 * @tc.steps: case1: recognizers_ is empty
108 * @tc.expected: step2. result equals.
109 */
110 exclusiveRecognizer->recognizers_.clear();
111 exclusiveRecognizer->CheckStates(0);
112 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
113
114 /**
115 * @tc.steps: step2. call CheckStates function and compare result.
116 * @tc.steps: case2: recognizers has nullptr
117 * @tc.expected: step2. result equals.
118 */
119 exclusiveRecognizer->recognizers_.clear();
120 exclusiveRecognizer->CheckStates(0);
121 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
122
123 /**
124 * @tc.steps: step2. call CheckStates function and compare result.
125 * @tc.steps: case3: recognizers has ptr
126 * @tc.expected: step2. result equals.
127 */
128 exclusiveRecognizer->recognizers_.clear();
129 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
130 exclusiveRecognizer->CheckStates(0);
131 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
132 }
133
134 /**
135 * @tc.name: RecognizerGroupCheckStatesTest002
136 * @tc.desc: Test RecognizerGroup function: CheckStates
137 * @tc.type: FUNC
138 */
139 HWTEST_F(GestureGroupTestNg, RecognizerGroupCheckStatesTest002, TestSize.Level1)
140 {
141 /**
142 * @tc.steps: step1. create RecognizerGroup
143 */
144 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
145 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
146 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
147 TouchEvent touchEventStart;
148 touchEventStart.id = 0;
149 clickRecognizerPtr->touchPoints_[0] = touchEventStart;
150 TouchEvent touchEventEnd;
151 touchEventEnd.id = 1;
152 clickRecognizerPtr->touchPoints_[1] = touchEventEnd;
153
154 std::vector<RefPtr<NGGestureRecognizer>> recognizers2 = {};
155 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers2);
156 exclusiveRecognizerPtr->touchPoints_[0] = touchEventStart;
157 exclusiveRecognizerPtr->touchPoints_[1] = touchEventEnd;
158
159 /**
160 * @tc.steps: step2. call CheckStates function and compare result.
161 * @tc.steps: case1: recognizers_ is empty
162 * @tc.expected: step2. result equals.
163 */
164 exclusiveRecognizer->recognizers_.clear();
165 exclusiveRecognizer->CheckStates(0);
166 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
167
168 /**
169 * @tc.steps: step2. call CheckStates function and compare result.
170 * @tc.steps: case2: recognizers has nullptr
171 * @tc.expected: step2. result equals.
172 */
173 exclusiveRecognizer->recognizers_.clear();
174 exclusiveRecognizer->CheckStates(0);
175 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
176
177 /**
178 * @tc.steps: step2. call CheckStates function and compare result.
179 * @tc.steps: case3: recognizers has ptr
180 * @tc.expected: step2. result equals.
181 */
182 exclusiveRecognizer->recognizers_.clear();
183 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
184 exclusiveRecognizer->CheckStates(0);
185 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
186
187 /**
188 * @tc.steps: step2. call CheckStates function and compare result.
189 * @tc.steps: case3: recognizers has ptr
190 * @tc.expected: step2. result equals.
191 */
192 exclusiveRecognizer->recognizers_.clear();
193 exclusiveRecognizer->recognizers_.push_back(exclusiveRecognizerPtr);
194 exclusiveRecognizer->CheckStates(0);
195 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
196 }
197
198 /**
199 * @tc.name: RecognizerGroupCheckStatesTest003
200 * @tc.desc: Test RecognizerGroup function: CheckStates
201 * @tc.type: FUNC
202 */
203 HWTEST_F(GestureGroupTestNg, RecognizerGroupCheckStatesTest003, TestSize.Level1)
204 {
205 /**
206 * @tc.steps: step1. create RecognizerGroup
207 */
208 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
209 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
210 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
211 TouchEvent touchEventStart;
212 touchEventStart.id = 0;
213 clickRecognizerPtr->touchPoints_[0] = touchEventStart;
214 TouchEvent touchEventEnd;
215 touchEventEnd.id = 1;
216 clickRecognizerPtr->touchPoints_[1] = touchEventEnd;
217
218 /**
219 * @tc.steps: step2. call CheckStates function and compare result.
220 * @tc.steps: case1: recognizers_ is empty
221 * @tc.expected: step2. result equals.
222 */
223 exclusiveRecognizer->recognizers_.clear();
224 exclusiveRecognizer->CheckStates(0);
225 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
226
227 /**
228 * @tc.steps: step2. call CheckStates function and compare result.
229 * @tc.steps: case2: recognizers has nullptr
230 * @tc.expected: step2. result equals.
231 */
232 exclusiveRecognizer->recognizers_.clear();
233 exclusiveRecognizer->CheckStates(0);
234 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
235
236 /**
237 * @tc.steps: step2. call CheckStates function and compare result.
238 * @tc.steps: case3: recognizers has ptr
239 * @tc.expected: step2. result equals.
240 */
241 exclusiveRecognizer->recognizers_.clear();
242 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
243 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
244 exclusiveRecognizer->CheckStates(0);
245 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
246
247 /**
248 * @tc.steps: step2. call CheckStates function and compare result.
249 * @tc.steps: case3: recognizers has ptr
250 * @tc.expected: step2. result equals.
251 */
252 exclusiveRecognizer->recognizers_.clear();
253 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
254 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
255 exclusiveRecognizer->CheckStates(0);
256 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
257
258 /**
259 * @tc.steps: step2. call CheckStates function and compare result.
260 * @tc.steps: case3: recognizers has ptr
261 * @tc.expected: step2. result equals.
262 */
263 exclusiveRecognizer->recognizers_.clear();
264 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
265 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
266 exclusiveRecognizer->CheckStates(0);
267 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
268
269 /**
270 * @tc.steps: step2. call CheckStates function and compare result.
271 * @tc.steps: case3: recognizers has ptr
272 * @tc.expected: step2. result equals.
273 */
274 exclusiveRecognizer->recognizers_.clear();
275 clickRecognizerPtr->refereeState_ = RefereeState::READY;
276 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
277 exclusiveRecognizer->CheckStates(0);
278 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
279
280 /**
281 * @tc.steps: step2. call CheckStates function and compare result.
282 * @tc.steps: case3: recognizers has ptr
283 * @tc.expected: step2. result equals.
284 */
285 exclusiveRecognizer->recognizers_.clear();
286 clickRecognizerPtr->refereeState_ = RefereeState::DETECTING;
287 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
288 exclusiveRecognizer->CheckStates(0);
289 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
290 }
291
292 /**
293 * @tc.name: RecognizerGroupCheckStatesTest005
294 * @tc.desc: Test RecognizerGroup function: CheckStates
295 * @tc.type: FUNC
296 */
297 HWTEST_F(GestureGroupTestNg, RecognizerGroupCheckStatesTest005, TestSize.Level1)
298 {
299 /**
300 * @tc.steps: step1. create RecognizerGroup
301 */
302 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
303 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
304 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
305 TouchEvent touchEventStart;
306 touchEventStart.id = 0;
307 clickRecognizerPtr->touchPoints_[0] = touchEventStart;
308 TouchEvent touchEventEnd;
309 touchEventEnd.id = 1;
310 clickRecognizerPtr->touchPoints_[1] = touchEventEnd;
311
312 std::vector<RefPtr<NGGestureRecognizer>> recognizers2 = {};
313 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers2);
314 exclusiveRecognizerPtr->touchPoints_[0] = touchEventStart;
315 exclusiveRecognizerPtr->touchPoints_[1] = touchEventEnd;
316
317 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
318 touchEventStart.id = 0;
319 clickRecognizerPtr2->touchPoints_[0] = touchEventStart;
320 touchEventEnd.id = 1;
321 clickRecognizerPtr2->touchPoints_[1] = touchEventEnd;
322 clickRecognizerPtr2->refereeState_ = RefereeState::DETECTING;
323 exclusiveRecognizerPtr->recognizers_.push_back(clickRecognizerPtr2);
324
325 /**
326 * @tc.steps: step2. call CheckStates function and compare result.
327 * @tc.steps: case1: recognizers_ is empty
328 * @tc.expected: step2. result equals.
329 */
330 exclusiveRecognizer->recognizers_.clear();
331 exclusiveRecognizer->CheckStates(0);
332 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
333
334 /**
335 * @tc.steps: step2. call CheckStates function and compare result.
336 * @tc.steps: case2: recognizers has nullptr
337 * @tc.expected: step2. result equals.
338 */
339 exclusiveRecognizer->recognizers_.clear();
340 exclusiveRecognizer->CheckStates(0);
341 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
342
343 /**
344 * @tc.steps: step2. call CheckStates function and compare result.
345 * @tc.steps: case3: recognizers has ptr
346 * @tc.expected: step2. result equals.
347 */
348 exclusiveRecognizer->recognizers_.clear();
349 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
350 exclusiveRecognizer->CheckStates(0);
351 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
352
353 /**
354 * @tc.steps: step2. call CheckStates function and compare result.
355 * @tc.steps: case3: recognizers has ptr
356 * @tc.expected: step2. result equals.
357 */
358 exclusiveRecognizer->recognizers_.clear();
359 exclusiveRecognizer->recognizers_.push_back(exclusiveRecognizerPtr);
360 exclusiveRecognizer->CheckStates(0);
361 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
362 }
363
364 /**
365 * @tc.name: RecognizerGroupOnResetStatusTest001
366 * @tc.desc: Test RecognizerGroup function: OnResetStatus
367 * @tc.type: FUNC
368 */
369 HWTEST_F(GestureGroupTestNg, RecognizerGroupOnResetStatusTest001, TestSize.Level1)
370 {
371 /**
372 * @tc.steps: step1. create RecognizerGroup
373 */
374 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
375 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
376 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
377
378 /**
379 * @tc.steps: step2. call OnResetStatus function and compare result.
380 * @tc.steps: case1: recognizers_ is empty
381 * @tc.expected: step2. result equals.
382 */
383 exclusiveRecognizer->recognizers_.clear();
384 exclusiveRecognizer->remainChildOnResetStatus_ = true;
385 exclusiveRecognizer->OnResetStatus();
386 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
387
388 /**
389 * @tc.steps: step2. call OnResetStatus function and compare result.
390 * @tc.steps: case2: recognizers has nullptr
391 * @tc.expected: step2. result equals.
392 */
393 exclusiveRecognizer->recognizers_.clear();
394 exclusiveRecognizer->recognizers_.push_back(nullptr);
395 exclusiveRecognizer->remainChildOnResetStatus_ = false;
396 exclusiveRecognizer->OnResetStatus();
397 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
398
399 /**
400 * @tc.steps: step2. call OnResetStatus function and compare result.
401 * @tc.steps: case3: recognizers has ptr
402 * @tc.expected: step2. result equals.
403 */
404 exclusiveRecognizer->recognizers_.clear();
405 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
406 exclusiveRecognizer->remainChildOnResetStatus_ = false;
407 exclusiveRecognizer->OnResetStatus();
408 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
409 }
410
411 /**
412 * @tc.name: RecognizerGroupTest003
413 * @tc.desc: Test RecognizerGroup function: AddChildren
414 * @tc.type: FUNC
415 */
416 HWTEST_F(GestureGroupTestNg, RecognizerGroupTest003, TestSize.Level1)
417 {
418 /**
419 * @tc.steps: step1. create RecognizerGroup
420 */
421 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
422 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
423 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
424 std::list<RefPtr<NGGestureRecognizer>> recognizersInput = {};
425
426 /**
427 * @tc.steps: step2. call OnFinishGestureReferee function and compare result.
428 * @tc.steps: case1: recognizers is empty
429 * @tc.expected: step2. result equals.
430 */
431 exclusiveRecognizer->AddChildren(recognizersInput);
432 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
433
434 /**
435 * @tc.steps: step2. call OnFinishGestureReferee function and compare result.
436 * @tc.steps: case2: recognizers is not empty
437 * @tc.expected: step2. result equals.
438 */
439 recognizersInput = { nullptr, clickRecognizerPtr, clickRecognizerPtr };
440 exclusiveRecognizer->AddChildren(recognizersInput);
441 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
442 }
443
444 /**
445 * @tc.name: RecognizerGroupTest004
446 * @tc.desc: Test RecognizerGroup function: Existed
447 * @tc.type: FUNC
448 */
449 HWTEST_F(GestureGroupTestNg, RecognizerGroupTest004, TestSize.Level1)
450 {
451 /**
452 * @tc.steps: step1. create RecognizerGroup
453 */
454 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
455 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
456 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
457
458 /**
459 * @tc.steps: step2. call Existed function and compare result.
460 * @tc.steps: case1: recognizers is empty
461 * @tc.expected: step2. result equals.
462 */
463 exclusiveRecognizer->Existed(clickRecognizerPtr);
464 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
465
466 /**
467 * @tc.steps: step2. call Existed function and compare result.
468 * @tc.steps: case2: recognizers is empty
469 * @tc.expected: step2. result equals.
470 */
471 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
472 exclusiveRecognizer->Existed(clickRecognizerPtr);
473 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
474 }
475
476 /**
477 * @tc.name: RecognizerGroupTest005
478 * @tc.desc: Test RecognizerGroup function: OnFlushTouchEventsBegin End Reset
479 * @tc.type: FUNC
480 */
481 HWTEST_F(GestureGroupTestNg, RecognizerGroupTest005, TestSize.Level1)
482 {
483 /**
484 * @tc.steps: step1. create RecognizerGroup
485 */
486 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
487 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
488 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
489
490 /**
491 * @tc.steps: step2. call function and compare result.
492 * @tc.steps: case1: recognizers is empty
493 * @tc.expected: step2. result equals.
494 */
495 exclusiveRecognizer->OnFlushTouchEventsBegin();
496 exclusiveRecognizer->OnFlushTouchEventsEnd();
497 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
498
499 /**
500 * @tc.steps: step2. call function and compare result.
501 * @tc.steps: case2: recognizers has nullptr
502 * @tc.expected: step2. result equals.
503 */
504 exclusiveRecognizer->recognizers_.push_back(nullptr);
505 exclusiveRecognizer->OnFlushTouchEventsBegin();
506 exclusiveRecognizer->OnFlushTouchEventsEnd();
507 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
508
509 /**
510 * @tc.steps: step2. call function and compare result.
511 * @tc.steps: case3: recognizers has ptr
512 * @tc.expected: step2. result equals.
513 */
514 exclusiveRecognizer->recognizers_.clear();
515 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
516 exclusiveRecognizer->OnFlushTouchEventsBegin();
517 exclusiveRecognizer->OnFlushTouchEventsEnd();
518 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
519
520 /**
521 * @tc.steps: step2. call function and compare result.
522 * @tc.steps: case4: recognizers has ptr
523 * @tc.expected: step2. result equals.
524 */
525 exclusiveRecognizer->remainChildOnResetStatus_ = true;
526 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
527 }
528
529 /**
530 * @tc.name: RecognizerGroupTest006
531 * @tc.desc: Test RecognizerGroup function: GetGroupRecognizer
532 * @tc.type: FUNC
533 */
534 HWTEST_F(GestureGroupTestNg, RecognizerGroupTest006, TestSize.Level1)
535 {
536 /**
537 * @tc.steps: step1. create RecognizerGroup
538 */
539 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
540 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
541
542 /**
543 * @tc.steps: step2. call function and compare result.
544 * @tc.steps: case1: recognizers is empty
545 * @tc.expected: step2. result equals.
546 */
547 exclusiveRecognizer->OnFlushTouchEventsBegin();
548 exclusiveRecognizer->OnFlushTouchEventsEnd();
549 exclusiveRecognizer->GetGroupRecognizer();
550 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
551 }
552
553 /**
554 * @tc.name: RecognizerGroupTest007
555 * @tc.desc: Test RecognizerGroup function: ForceReject
556 * @tc.type: FUNC
557 */
558 HWTEST_F(GestureGroupTestNg, RecognizerGroupTest007, TestSize.Level1)
559 {
560 /**
561 * @tc.steps: step1. create RecognizerGroup
562 */
563 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
564 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
565 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
566
567 /**
568 * @tc.steps: step2. call function and compare result.
569 * @tc.steps: case1: recognizers is empty
570 * @tc.expected: step2. result equals.
571 */
572 exclusiveRecognizer->recognizers_.clear();
573 exclusiveRecognizer->OnFlushTouchEventsBegin();
574 exclusiveRecognizer->OnFlushTouchEventsEnd();
575 exclusiveRecognizer->ForceReject();
576 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
577
578 /**
579 * @tc.steps: step2. call function and compare result.
580 * @tc.steps: case1: recognizers is empty
581 * @tc.expected: step2. result equals.
582 */
583 exclusiveRecognizer->recognizers_.clear();
584 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
585 exclusiveRecognizer->OnFlushTouchEventsBegin();
586 exclusiveRecognizer->OnFlushTouchEventsEnd();
587 exclusiveRecognizer->ForceReject();
588 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
589 }
590
591 /**
592 * @tc.name: RecognizerGroupForceRejectTest001
593 * @tc.desc: Test RecognizerGroup function: ForceReject
594 * @tc.type: FUNC
595 */
596 HWTEST_F(GestureGroupTestNg, RecognizerGroupForceRejectTest001, TestSize.Level1)
597 {
598 /**
599 * @tc.steps: step1. create RecognizerGroup
600 */
601 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
602 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
603 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
604 std::vector<RefPtr<NGGestureRecognizer>> recognizers2 = {};
605 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers2);
606
607 /**
608 * @tc.steps: step2. call function and compare result.
609 * @tc.steps: case1: recognizers is empty
610 * @tc.expected: step2. result equals.
611 */
612 exclusiveRecognizer->recognizers_.clear();
613 exclusiveRecognizer->recognizers_.push_back(exclusiveRecognizerPtr);
614 exclusiveRecognizer->OnFlushTouchEventsBegin();
615 exclusiveRecognizer->OnFlushTouchEventsEnd();
616 exclusiveRecognizer->ForceReject();
617 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
618
619 /**
620 * @tc.steps: step2. call function and compare result.
621 * @tc.steps: case1: recognizers is empty
622 * @tc.expected: step2. result equals.
623 */
624 exclusiveRecognizer->recognizers_.clear();
625 clickRecognizerPtr->refereeState_ = RefereeState::DETECTING;
626 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
627 exclusiveRecognizer->OnFlushTouchEventsBegin();
628 exclusiveRecognizer->OnFlushTouchEventsEnd();
629 exclusiveRecognizer->ForceReject();
630 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
631
632 /**
633 * @tc.steps: step2. call function and compare result.
634 * @tc.steps: case1: recognizers is empty
635 * @tc.expected: step2. result equals.
636 */
637 exclusiveRecognizer->recognizers_.clear();
638 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
639 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
640 exclusiveRecognizer->OnFlushTouchEventsBegin();
641 exclusiveRecognizer->OnFlushTouchEventsEnd();
642 exclusiveRecognizer->ForceReject();
643 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
644
645 /**
646 * @tc.steps: step2. call function and compare result.
647 * @tc.steps: case1: recognizers is empty
648 * @tc.expected: step2. result equals.
649 */
650 exclusiveRecognizer->recognizers_.clear();
651 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
652 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
653 exclusiveRecognizer->OnFlushTouchEventsBegin();
654 exclusiveRecognizer->OnFlushTouchEventsEnd();
655 exclusiveRecognizer->ForceReject();
656 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
657
658 /**
659 * @tc.steps: step2. call function and compare result.
660 * @tc.steps: case1: recognizers is empty
661 * @tc.expected: step2. result equals.
662 */
663 exclusiveRecognizer->recognizers_.clear();
664 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
665 exclusiveRecognizer->recognizers_.push_back(clickRecognizerPtr);
666 exclusiveRecognizer->OnFlushTouchEventsBegin();
667 exclusiveRecognizer->OnFlushTouchEventsEnd();
668 exclusiveRecognizer->ForceReject();
669 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 1);
670 }
671
672 /**
673 * @tc.name: RecognizerGroupTest008
674 * @tc.desc: Test RecognizerGroup function: CheckAllFailed
675 * @tc.type: FUNC
676 */
677 HWTEST_F(GestureGroupTestNg, RecognizerGroupTest008, TestSize.Level1)
678 {
679 /**
680 * @tc.steps: step1. create RecognizerGroup
681 */
682 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
683 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
684
685 /**
686 * @tc.steps: step2. call function and compare result.
687 * @tc.steps: case1: recognizers is empty
688 * @tc.expected: step2. result equals.
689 */
690 exclusiveRecognizer->OnFlushTouchEventsBegin();
691 exclusiveRecognizer->OnFlushTouchEventsEnd();
692 bool result = exclusiveRecognizer->CheckAllFailed();
693 EXPECT_EQ(exclusiveRecognizer->recognizers_.size(), 0);
694 EXPECT_TRUE(result);
695 }
696
697 /**
698 * @tc.name: GestureGroupTest001
699 * @tc.desc: Test GestureGroup CreateRecognizer function
700 */
701 HWTEST_F(GestureGroupTestNg, GestureGroupTest001, TestSize.Level1)
702 {
703 /**
704 * @tc.steps: step1. create GestureGroup.
705 */
706 GestureGroupModelNG gestureGroupModelNG;
707 gestureGroupModelNG.Create(0);
708
709 RefPtr<GestureProcessor> gestureProcessor;
710 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
711 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
712 EXPECT_EQ(gestureGroupNG->mode_, GestureMode::Sequence);
713
714 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
715
716 /**
717 * @tc.steps: step2. call CreateRecognizer function and compare result
718 * @tc.steps: case1: GestureMode::Begin
719 */
720 gestureGroup.priority_ = GesturePriority::Low;
721 gestureGroup.gestureMask_ = GestureMask::Normal;
722 gestureGroup.mode_ = GestureMode::Begin;
723 auto groupRecognizer = gestureGroup.CreateRecognizer();
724 EXPECT_EQ(groupRecognizer, nullptr);
725
726 /**
727 * @tc.steps: step2. call CreateRecognizer function and compare result
728 * @tc.steps: case2: GestureMode::Sequence
729 */
730 gestureGroup.priority_ = GesturePriority::Low;
731 gestureGroup.gestureMask_ = GestureMask::Normal;
732 gestureGroup.mode_ = GestureMode::Sequence;
733 groupRecognizer = gestureGroup.CreateRecognizer();
734 EXPECT_NE(groupRecognizer, nullptr);
735 EXPECT_EQ(groupRecognizer->GetPriority(), GesturePriority::Low);
736 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
737
738 /**
739 * @tc.steps: step2. call CreateRecognizer function and compare result
740 * @tc.steps: case3: GestureMode::Parallel
741 */
742 gestureGroup.priority_ = GesturePriority::Low;
743 gestureGroup.gestureMask_ = GestureMask::Normal;
744 gestureGroup.mode_ = GestureMode::Parallel;
745 groupRecognizer = gestureGroup.CreateRecognizer();
746 EXPECT_NE(groupRecognizer, nullptr);
747 EXPECT_EQ(groupRecognizer->GetPriority(), GesturePriority::Low);
748 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
749
750 /**
751 * @tc.steps: step2. call CreateRecognizer function and compare result
752 * @tc.steps: case4: GestureMode::Exclusive
753 */
754 gestureGroup.priority_ = GesturePriority::Low;
755 gestureGroup.gestureMask_ = GestureMask::Normal;
756 gestureGroup.mode_ = GestureMode::Exclusive;
757 groupRecognizer = gestureGroup.CreateRecognizer();
758 EXPECT_NE(groupRecognizer, nullptr);
759 EXPECT_EQ(groupRecognizer->GetPriority(), GesturePriority::Low);
760 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
761
762 /**
763 * @tc.steps: step2. call CreateRecognizer function and compare result
764 * @tc.steps: case5: GestureMode::End
765 */
766 gestureGroup.priority_ = GesturePriority::Low;
767 gestureGroup.gestureMask_ = GestureMask::Normal;
768 gestureGroup.mode_ = GestureMode::End;
769 groupRecognizer = gestureGroup.CreateRecognizer();
770 EXPECT_EQ(groupRecognizer, nullptr);
771
772 /**
773 * @tc.steps: step2. call CreateRecognizer function and compare result
774 * @tc.steps: case6: GestureMode::Sequence, have onActionCancelId_
775 */
776 gestureGroup.priority_ = GesturePriority::Low;
777 gestureGroup.gestureMask_ = GestureMask::Normal;
778 gestureGroup.mode_ = GestureMode::Sequence;
779 std::unique_ptr<GestureEventFunc> onActionCancelId;
780 gestureGroup.onActionCancelId_ = std::move(onActionCancelId);
781 groupRecognizer = gestureGroup.CreateRecognizer();
782 EXPECT_NE(groupRecognizer, nullptr);
783 }
784
785 /**
786 * @tc.name: GestureGroupGestureGroupTest003
787 * @tc.desc: Test GestureGroup GestureGroup
788 */
789 HWTEST_F(GestureGroupTestNg, GestureGroupGestureGroupTest003, TestSize.Level1)
790 {
791 /**
792 * @tc.steps: step1. create GestureGroup.
793 */
794 GestureGroupModelNG gestureGroupModelNG;
795 gestureGroupModelNG.Create(0);
796
797 RefPtr<GestureProcessor> gestureProcessor;
798 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
799 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
800 std::vector<RefPtr<Gesture>> gestures;
801 RefPtr<LongPressGesture> LongPressGesturePtr = AceType::MakeRefPtr<LongPressGesture>(FINGER_NUMBER,
802 false, LONG_PRESS_DURATION, false, false);
803 gestures.push_back(LongPressGesturePtr);
804
805 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
806 gestureGroup.gestures_ = gestures;
807
808 /**
809 * @tc.steps: step2. call CreateRecognizer function and compare result
810 * @tc.steps: case1: GestureMode::Begin
811 */
812 gestureGroup.priority_ = GesturePriority::Low;
813 gestureGroup.gestureMask_ = GestureMask::Normal;
814 gestureGroup.mode_ = GestureMode::Begin;
815 auto groupRecognizer = gestureGroup.CreateRecognizer();
816 EXPECT_EQ(groupRecognizer, nullptr);
817
818 /**
819 * @tc.steps: step2. call CreateRecognizer function and compare result
820 * @tc.steps: case2: GestureMode::Sequence
821 */
822 gestureGroup.priority_ = GesturePriority::Low;
823 gestureGroup.gestureMask_ = GestureMask::Normal;
824 gestureGroup.mode_ = GestureMode::Sequence;
825 groupRecognizer = gestureGroup.CreateRecognizer();
826 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
827
828 /**
829 * @tc.steps: step2. call CreateRecognizer function and compare result
830 * @tc.steps: case3: GestureMode::Parallel
831 */
832 gestureGroup.priority_ = GesturePriority::Low;
833 gestureGroup.gestureMask_ = GestureMask::Normal;
834 gestureGroup.mode_ = GestureMode::Parallel;
835 groupRecognizer = gestureGroup.CreateRecognizer();
836 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
837
838 /**
839 * @tc.steps: step2. call CreateRecognizer function and compare result
840 * @tc.steps: case4: GestureMode::Exclusive
841 */
842 gestureGroup.priority_ = GesturePriority::Low;
843 gestureGroup.gestureMask_ = GestureMask::Normal;
844 gestureGroup.mode_ = GestureMode::Exclusive;
845 groupRecognizer = gestureGroup.CreateRecognizer();
846 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
847
848 /**
849 * @tc.steps: step2. call CreateRecognizer function and compare result
850 * @tc.steps: case5: GestureMode::End
851 */
852 gestureGroup.priority_ = GesturePriority::Low;
853 gestureGroup.gestureMask_ = GestureMask::Normal;
854 gestureGroup.mode_ = GestureMode::End;
855 groupRecognizer = gestureGroup.CreateRecognizer();
856 EXPECT_EQ(groupRecognizer, nullptr);
857
858 /**
859 * @tc.steps: step2. call CreateRecognizer function and compare result
860 * @tc.steps: case6: GestureMode::Sequence, have onActionCancelId_
861 */
862 gestureGroup.priority_ = GesturePriority::Low;
863 gestureGroup.gestureMask_ = GestureMask::Normal;
864 gestureGroup.mode_ = GestureMode::Sequence;
865 std::unique_ptr<GestureEventFunc> onActionCancelId;
866 gestureGroup.onActionCancelId_ = std::move(onActionCancelId);
867 groupRecognizer = gestureGroup.CreateRecognizer();
868 EXPECT_NE(groupRecognizer, nullptr);
869 }
870
871 /**
872 * @tc.name: GestureGroupCreateRecognizerTest001
873 * @tc.desc: Test GestureGroup CreateRecognizer function
874 */
875 HWTEST_F(GestureGroupTestNg, GestureGroupCreateRecognizerTest001, TestSize.Level1)
876 {
877 /**
878 * @tc.steps: step1. create GestureGroup.
879 */
880 GestureGroupModelNG gestureGroupModelNG;
881 gestureGroupModelNG.Create(0);
882
883 RefPtr<GestureProcessor> gestureProcessor;
884 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
885 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
886 EXPECT_EQ(gestureGroupNG->mode_, GestureMode::Sequence);
887
888 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
889
890 /**
891 * @tc.steps: step2. call CreateRecognizer function and compare result
892 * @tc.steps: case1: GestureMode::Begin
893 */
894 gestureGroup.priority_ = GesturePriority::Low;
895 gestureGroup.gestureMask_ = GestureMask::Normal;
896 gestureGroup.mode_ = GestureMode::Begin;
897 auto groupRecognizer = gestureGroup.CreateRecognizer();
898 EXPECT_EQ(groupRecognizer, nullptr);
899
900 /**
901 * @tc.steps: step2. call CreateRecognizer function and compare result
902 * @tc.steps: case2: GestureMode::Sequence
903 */
904 gestureGroup.priority_ = GesturePriority::Low;
905 gestureGroup.gestureMask_ = GestureMask::Normal;
906 gestureGroup.mode_ = GestureMode::Sequence;
__anon0ff4970d0102(const GestureEvent& info) 907 auto onActionCancel = [](const GestureEvent& info) { return true; };
908 gestureGroup.SetOnActionCancelId(onActionCancel);
909 groupRecognizer = gestureGroup.CreateRecognizer();
910 EXPECT_NE(groupRecognizer, nullptr);
911 EXPECT_EQ(groupRecognizer->GetPriority(), GesturePriority::Low);
912 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
913 }
914
915 /**
916 * @tc.name: GestureGroupTestNg001
917 * @tc.desc: Test GestureGroup Deserialize function
918 */
919 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg001, TestSize.Level1)
920 {
921 GestureGroupModelNG gestureGroupModelNG;
922 gestureGroupModelNG.Create(0);
923 RefPtr<GestureProcessor> gestureProcessor;
924 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
925 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
926 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
927 const char* buff = "-123bytes";
928 gestureGroup.Deserialize(buff);
929 const char* buff2 = nullptr;
930 auto result = gestureGroup.Deserialize(buff2);
931 char buff3[8] = { 0, 0, 0, 0, 3 & 0xFF, 0, 0, 0 };
932 gestureGroup.Deserialize(buff3);
933 char buff4[8] = { 0, 0, 0, 0, 7 & 0xFF, 0, 0, 0 };
934 gestureGroup.Deserialize(buff4);
935 char buff5[8] = { 0, 0, 0, 0, 11 & 0xFF, 0, 0, 0 };
936 gestureGroup.Deserialize(buff5);
937 char buff6[8] = { 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF };
938 gestureGroup.Deserialize(buff6);
939 char buff7[20] = { 0, 0, 0, 0, 13 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0 };
940 gestureGroup.Deserialize(buff7);
941 char buff8[8] = { 0, 0, 0, 0, 12 & 0xFF, 0, 0, 0 };
942 gestureGroup.Deserialize(buff8);
943 char buff9[16] = { 0, 0, 0, 0, 172 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0 };
944 gestureGroup.Deserialize(buff9);
945 EXPECT_EQ(result, -1);
946 }
947
948 /**
949 * @tc.name: GestureGroupTestNg002
950 * @tc.desc: Test GestureGroup SizeofMe function
951 */
952 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg002, TestSize.Level1)
953 {
954 GestureGroupModelNG gestureGroupModelNG;
955 gestureGroupModelNG.Create(0);
956 RefPtr<GestureProcessor> gestureProcessor;
957 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
958 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
959 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
960 gestureGroup.MakeGesture(GestureType::GROUP);
961 auto result = gestureGroup.MakeGesture(GestureType::LONG_PRESS);
962 EXPECT_EQ(result, nullptr);
963 }
964
965 /**
966 * @tc.name: GestureGroupTestNg003
967 * @tc.desc: Test GestureGroup Serialize function
968 */
969 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg003, TestSize.Level1)
970 {
971 GestureGroupModelNG gestureGroupModelNG;
972 gestureGroupModelNG.Create(0);
973 RefPtr<GestureProcessor> gestureProcessor;
974 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
975 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
976 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
977 char* buff = nullptr;
978 auto result = gestureGroup.Serialize(buff);
979 char buff2[16] = { 0, 0, 0, 0, 172 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0 };
980 gestureGroup.Serialize(buff2);
981 EXPECT_EQ(result, -1);
982 }
983
984 /**
985 * @tc.name: GestureGroupTestNg004
986 * @tc.desc: Test GestureGroup RemoveGesture function
987 */
988 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg004, TestSize.Level1)
989 {
990 bool result = true;
991 GestureGroupModelNG gestureGroupModelNG;
992 gestureGroupModelNG.Create(0);
993 RefPtr<GestureProcessor> gestureProcessor;
994 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
995 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
996 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
997 auto gesture = AceType::MakeRefPtr<TapGesture>();
998 auto gesture2 = AceType::MakeRefPtr<TapGesture>();
999 auto gesture3 = AceType::MakeRefPtr<TapGesture>();
1000 gestureGroup.AddGesture(gesture);
1001 gestureGroup.AddGesture(gesture2);
1002 gestureGroup.AddGesture(gesture3);
1003
1004 std::vector<RefPtr<Gesture>> gestures;
1005 auto longPressGestureOne = AceType::MakeRefPtr<LongPressGesture>(5, false, 1);
1006 longPressGestureOne->SetTag("HELLO");
1007 gestures.emplace_back(longPressGestureOne);
1008 auto longPressGestureTwo = AceType::MakeRefPtr<LongPressGesture>(5, false, 1);
1009 gestures.emplace_back(longPressGestureTwo);
1010 auto group = AceType::MakeRefPtr<GestureGroup>(GestureMode::Exclusive, gestures);
1011 gestureGroup.AddGesture(group);
1012
1013 gestureGroup.RemoveGesture(gesture2);
1014 EXPECT_TRUE(result);
1015 }
1016
1017 /**
1018 * @tc.name: GestureGroupTestNg005
1019 * @tc.desc: Test GestureGroup RemoveChildrenByTag function
1020 */
1021 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg005, TestSize.Level1)
1022 {
1023 bool result = true;
1024 GestureGroupModelNG gestureGroupModelNG;
1025 gestureGroupModelNG.Create(0);
1026 RefPtr<GestureProcessor> gestureProcessor;
1027 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
1028 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
1029 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
1030
1031 std::vector<RefPtr<Gesture>> gestures;
1032 auto longPressGestureOne = AceType::MakeRefPtr<LongPressGesture>(5, false, 1);
1033 longPressGestureOne->SetTag("HELLO");
1034 gestures.emplace_back(longPressGestureOne);
1035 auto longPressGestureTwo = AceType::MakeRefPtr<LongPressGesture>(5, false, 1);
1036 gestures.emplace_back(longPressGestureTwo);
1037 auto group = AceType::MakeRefPtr<GestureGroup>(GestureMode::Exclusive, gestures);
1038 gestureGroup.AddGesture(group);
1039
1040 gestureGroup.RemoveChildrenByTag("HELLO", result);
1041 EXPECT_TRUE(result);
1042 }
1043
1044 /**
1045 * @tc.name: GestureGroupTestNg006
1046 * @tc.desc: Test Pan_Gesture Deserialize function
1047 */
1048 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg006, TestSize.Level1)
1049 {
1050 PanDirection panDirection;
1051 panDirection.type = PanDirection::RIGHT;
1052 auto panGesture = AceType::MakeRefPtr<PanGesture>(SINGLE_FINGER_NUMBER, panDirection, PAN_DISTANCE);
1053 const char* buff = nullptr;
1054 auto result = panGesture->Deserialize(buff);
1055 char buff2[320] = { 0, 0, 0, 0, 13 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0 };
1056 panGesture->Deserialize(buff2);
1057 EXPECT_EQ(result, -1);
1058 }
1059
1060 /**
1061 * @tc.name: GestureGroupTestNg007
1062 * @tc.desc: Test Pan_Gesture Serialize function
1063 */
1064 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg007, TestSize.Level1)
1065 {
1066 PanDirection panDirection;
1067 panDirection.type = PanDirection::RIGHT;
1068 auto panGesture = AceType::MakeRefPtr<PanGesture>(SINGLE_FINGER_NUMBER, panDirection, PAN_DISTANCE);
1069 char* buff = nullptr;
1070 auto result = panGesture->Serialize(buff);
1071 char buff2[320] = { 0, 0, 0, 0, 172 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0 };
1072 panGesture->Serialize(buff2);
1073 EXPECT_EQ(result, -1);
1074 }
1075 } // namespace OHOS::Ace::NG