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: RecognizerGroupTest009
699 * @tc.desc: Test RecognizerGroup function: HandleEvent
700 * @tc.type: FUNC
701 */
702 HWTEST_F(GestureGroupTestNg, RecognizerGroupTest009, TestSize.Level1)
703 {
704 /**
705 * @tc.steps: step1. create RecognizerGroup
706 */
707 RefPtr<ClickRecognizer> clickRecognizer1 = AceType::MakeRefPtr<ClickRecognizer>();
708 RefPtr<ClickRecognizer> clickRecognizer2 = AceType::MakeRefPtr<ClickRecognizer>();
709
710 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {clickRecognizer1, clickRecognizer2};
711 RefPtr<ExclusiveRecognizer> exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
712
713 /**
714 * @tc.steps: step2. call function and compare result.
715 * @tc.steps: case1: recognizers_ receive event
716 * @tc.expected: step2. result equals.
717 */
718 TouchEvent touchEvent;
719 bool result;
720 touchEvent.id = 0;
721 clickRecognizer1->BeginReferee(0);
722 result = exclusiveRecognizer->HandleEvent(touchEvent);
723 EXPECT_EQ(result, true);
724 EXPECT_EQ(clickRecognizer1->refereeState_, RefereeState::READY);
725 }
726
727 /**
728 * @tc.name: GestureGroupTest001
729 * @tc.desc: Test GestureGroup CreateRecognizer function
730 */
731 HWTEST_F(GestureGroupTestNg, GestureGroupTest001, TestSize.Level1)
732 {
733 /**
734 * @tc.steps: step1. create GestureGroup.
735 */
736 GestureGroupModelNG gestureGroupModelNG;
737 gestureGroupModelNG.Create(0);
738
739 RefPtr<GestureProcessor> gestureProcessor;
740 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
741 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
742 EXPECT_EQ(gestureGroupNG->mode_, GestureMode::Sequence);
743
744 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
745
746 /**
747 * @tc.steps: step2. call CreateRecognizer function and compare result
748 * @tc.steps: case1: GestureMode::Begin
749 */
750 gestureGroup.priority_ = GesturePriority::Low;
751 gestureGroup.gestureMask_ = GestureMask::Normal;
752 gestureGroup.mode_ = GestureMode::Begin;
753 auto groupRecognizer = gestureGroup.CreateRecognizer();
754 EXPECT_EQ(groupRecognizer, nullptr);
755
756 /**
757 * @tc.steps: step2. call CreateRecognizer function and compare result
758 * @tc.steps: case2: GestureMode::Sequence
759 */
760 gestureGroup.priority_ = GesturePriority::Low;
761 gestureGroup.gestureMask_ = GestureMask::Normal;
762 gestureGroup.mode_ = GestureMode::Sequence;
763 groupRecognizer = gestureGroup.CreateRecognizer();
764 EXPECT_NE(groupRecognizer, nullptr);
765 EXPECT_EQ(groupRecognizer->GetPriority(), GesturePriority::Low);
766 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
767
768 /**
769 * @tc.steps: step2. call CreateRecognizer function and compare result
770 * @tc.steps: case3: GestureMode::Parallel
771 */
772 gestureGroup.priority_ = GesturePriority::Low;
773 gestureGroup.gestureMask_ = GestureMask::Normal;
774 gestureGroup.mode_ = GestureMode::Parallel;
775 groupRecognizer = gestureGroup.CreateRecognizer();
776 EXPECT_NE(groupRecognizer, nullptr);
777 EXPECT_EQ(groupRecognizer->GetPriority(), GesturePriority::Low);
778 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
779
780 /**
781 * @tc.steps: step2. call CreateRecognizer function and compare result
782 * @tc.steps: case4: GestureMode::Exclusive
783 */
784 gestureGroup.priority_ = GesturePriority::Low;
785 gestureGroup.gestureMask_ = GestureMask::Normal;
786 gestureGroup.mode_ = GestureMode::Exclusive;
787 groupRecognizer = gestureGroup.CreateRecognizer();
788 EXPECT_NE(groupRecognizer, nullptr);
789 EXPECT_EQ(groupRecognizer->GetPriority(), GesturePriority::Low);
790 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
791
792 /**
793 * @tc.steps: step2. call CreateRecognizer function and compare result
794 * @tc.steps: case5: GestureMode::End
795 */
796 gestureGroup.priority_ = GesturePriority::Low;
797 gestureGroup.gestureMask_ = GestureMask::Normal;
798 gestureGroup.mode_ = GestureMode::End;
799 groupRecognizer = gestureGroup.CreateRecognizer();
800 EXPECT_EQ(groupRecognizer, nullptr);
801
802 /**
803 * @tc.steps: step2. call CreateRecognizer function and compare result
804 * @tc.steps: case6: GestureMode::Sequence, have onActionCancelId_
805 */
806 gestureGroup.priority_ = GesturePriority::Low;
807 gestureGroup.gestureMask_ = GestureMask::Normal;
808 gestureGroup.mode_ = GestureMode::Sequence;
809 std::unique_ptr<GestureEventFunc> onActionCancelId;
810 gestureGroup.onActionCancelId_ = std::move(onActionCancelId);
811 groupRecognizer = gestureGroup.CreateRecognizer();
812 EXPECT_NE(groupRecognizer, nullptr);
813 }
814
815 /**
816 * @tc.name: GestureGroupGestureGroupTest003
817 * @tc.desc: Test GestureGroup GestureGroup
818 */
819 HWTEST_F(GestureGroupTestNg, GestureGroupGestureGroupTest003, TestSize.Level1)
820 {
821 /**
822 * @tc.steps: step1. create GestureGroup.
823 */
824 GestureGroupModelNG gestureGroupModelNG;
825 gestureGroupModelNG.Create(0);
826
827 RefPtr<GestureProcessor> gestureProcessor;
828 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
829 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
830 std::vector<RefPtr<Gesture>> gestures;
831 RefPtr<LongPressGesture> LongPressGesturePtr = AceType::MakeRefPtr<LongPressGesture>(FINGER_NUMBER,
832 false, LONG_PRESS_DURATION, false, false);
833 gestures.push_back(LongPressGesturePtr);
834
835 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
836 gestureGroup.gestures_ = gestures;
837
838 /**
839 * @tc.steps: step2. call CreateRecognizer function and compare result
840 * @tc.steps: case1: GestureMode::Begin
841 */
842 gestureGroup.priority_ = GesturePriority::Low;
843 gestureGroup.gestureMask_ = GestureMask::Normal;
844 gestureGroup.mode_ = GestureMode::Begin;
845 auto groupRecognizer = gestureGroup.CreateRecognizer();
846 EXPECT_EQ(groupRecognizer, nullptr);
847
848 /**
849 * @tc.steps: step2. call CreateRecognizer function and compare result
850 * @tc.steps: case2: GestureMode::Sequence
851 */
852 gestureGroup.priority_ = GesturePriority::Low;
853 gestureGroup.gestureMask_ = GestureMask::Normal;
854 gestureGroup.mode_ = GestureMode::Sequence;
855 groupRecognizer = gestureGroup.CreateRecognizer();
856 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
857
858 /**
859 * @tc.steps: step2. call CreateRecognizer function and compare result
860 * @tc.steps: case3: GestureMode::Parallel
861 */
862 gestureGroup.priority_ = GesturePriority::Low;
863 gestureGroup.gestureMask_ = GestureMask::Normal;
864 gestureGroup.mode_ = GestureMode::Parallel;
865 groupRecognizer = gestureGroup.CreateRecognizer();
866 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
867
868 /**
869 * @tc.steps: step2. call CreateRecognizer function and compare result
870 * @tc.steps: case4: GestureMode::Exclusive
871 */
872 gestureGroup.priority_ = GesturePriority::Low;
873 gestureGroup.gestureMask_ = GestureMask::Normal;
874 gestureGroup.mode_ = GestureMode::Exclusive;
875 groupRecognizer = gestureGroup.CreateRecognizer();
876 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
877
878 /**
879 * @tc.steps: step2. call CreateRecognizer function and compare result
880 * @tc.steps: case5: GestureMode::End
881 */
882 gestureGroup.priority_ = GesturePriority::Low;
883 gestureGroup.gestureMask_ = GestureMask::Normal;
884 gestureGroup.mode_ = GestureMode::End;
885 groupRecognizer = gestureGroup.CreateRecognizer();
886 EXPECT_EQ(groupRecognizer, nullptr);
887
888 /**
889 * @tc.steps: step2. call CreateRecognizer function and compare result
890 * @tc.steps: case6: GestureMode::Sequence, have onActionCancelId_
891 */
892 gestureGroup.priority_ = GesturePriority::Low;
893 gestureGroup.gestureMask_ = GestureMask::Normal;
894 gestureGroup.mode_ = GestureMode::Sequence;
895 std::unique_ptr<GestureEventFunc> onActionCancelId;
896 gestureGroup.onActionCancelId_ = std::move(onActionCancelId);
897 groupRecognizer = gestureGroup.CreateRecognizer();
898 EXPECT_NE(groupRecognizer, nullptr);
899 }
900
901 /**
902 * @tc.name: GestureGroupCreateRecognizerTest001
903 * @tc.desc: Test GestureGroup CreateRecognizer function
904 */
905 HWTEST_F(GestureGroupTestNg, GestureGroupCreateRecognizerTest001, TestSize.Level1)
906 {
907 /**
908 * @tc.steps: step1. create GestureGroup.
909 */
910 GestureGroupModelNG gestureGroupModelNG;
911 gestureGroupModelNG.Create(0);
912
913 RefPtr<GestureProcessor> gestureProcessor;
914 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
915 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
916 EXPECT_EQ(gestureGroupNG->mode_, GestureMode::Sequence);
917
918 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
919
920 /**
921 * @tc.steps: step2. call CreateRecognizer function and compare result
922 * @tc.steps: case1: GestureMode::Begin
923 */
924 gestureGroup.priority_ = GesturePriority::Low;
925 gestureGroup.gestureMask_ = GestureMask::Normal;
926 gestureGroup.mode_ = GestureMode::Begin;
927 auto groupRecognizer = gestureGroup.CreateRecognizer();
928 EXPECT_EQ(groupRecognizer, nullptr);
929
930 /**
931 * @tc.steps: step2. call CreateRecognizer function and compare result
932 * @tc.steps: case2: GestureMode::Sequence
933 */
934 gestureGroup.priority_ = GesturePriority::Low;
935 gestureGroup.gestureMask_ = GestureMask::Normal;
936 gestureGroup.mode_ = GestureMode::Sequence;
__anon89cda82f0102(const GestureEvent& info) 937 auto onActionCancel = [](const GestureEvent& info) { return true; };
938 gestureGroup.SetOnActionCancelId(onActionCancel);
939 groupRecognizer = gestureGroup.CreateRecognizer();
940 EXPECT_NE(groupRecognizer, nullptr);
941 EXPECT_EQ(groupRecognizer->GetPriority(), GesturePriority::Low);
942 EXPECT_EQ(groupRecognizer->GetPriorityMask(), GestureMask::Normal);
943 }
944
945 /**
946 * @tc.name: GestureGroupTestNg001
947 * @tc.desc: Test GestureGroup Deserialize function
948 */
949 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg001, TestSize.Level1)
950 {
951 GestureGroupModelNG gestureGroupModelNG;
952 gestureGroupModelNG.Create(0);
953 RefPtr<GestureProcessor> gestureProcessor;
954 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
955 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
956 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
957 const char* buff = "-123bytes";
958 gestureGroup.Deserialize(buff);
959 const char* buff2 = nullptr;
960 auto result = gestureGroup.Deserialize(buff2);
961 char buff3[8] = { 0, 0, 0, 0, 3 & 0xFF, 0, 0, 0 };
962 gestureGroup.Deserialize(buff3);
963 char buff4[8] = { 0, 0, 0, 0, 7 & 0xFF, 0, 0, 0 };
964 gestureGroup.Deserialize(buff4);
965 char buff5[8] = { 0, 0, 0, 0, 11 & 0xFF, 0, 0, 0 };
966 gestureGroup.Deserialize(buff5);
967 char buff6[8] = { 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF };
968 gestureGroup.Deserialize(buff6);
969 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 };
970 gestureGroup.Deserialize(buff7);
971 char buff8[8] = { 0, 0, 0, 0, 12 & 0xFF, 0, 0, 0 };
972 gestureGroup.Deserialize(buff8);
973 char buff9[16] = { 0, 0, 0, 0, 172 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0 };
974 gestureGroup.Deserialize(buff9);
975 EXPECT_EQ(result, -1);
976 }
977
978 /**
979 * @tc.name: GestureGroupTestNg002
980 * @tc.desc: Test GestureGroup SizeofMe function
981 */
982 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg002, TestSize.Level1)
983 {
984 GestureGroupModelNG gestureGroupModelNG;
985 gestureGroupModelNG.Create(0);
986 RefPtr<GestureProcessor> gestureProcessor;
987 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
988 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
989 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
990 gestureGroup.MakeGesture(GestureType::GROUP);
991 auto result = gestureGroup.MakeGesture(GestureType::LONG_PRESS);
992 EXPECT_EQ(result, nullptr);
993 }
994
995 /**
996 * @tc.name: GestureGroupTestNg003
997 * @tc.desc: Test GestureGroup Serialize function
998 */
999 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg003, TestSize.Level1)
1000 {
1001 GestureGroupModelNG gestureGroupModelNG;
1002 gestureGroupModelNG.Create(0);
1003 RefPtr<GestureProcessor> gestureProcessor;
1004 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
1005 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
1006 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
1007 char* buff = nullptr;
1008 auto result = gestureGroup.Serialize(buff);
1009 char buff2[16] = { 0, 0, 0, 0, 172 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0 };
1010 gestureGroup.Serialize(buff2);
1011 EXPECT_EQ(result, -1);
1012 }
1013
1014 /**
1015 * @tc.name: GestureGroupTestNg004
1016 * @tc.desc: Test GestureGroup RemoveGesture function
1017 */
1018 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg004, TestSize.Level1)
1019 {
1020 bool result = true;
1021 GestureGroupModelNG gestureGroupModelNG;
1022 gestureGroupModelNG.Create(0);
1023 RefPtr<GestureProcessor> gestureProcessor;
1024 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
1025 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
1026 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
1027 auto gesture = AceType::MakeRefPtr<TapGesture>();
1028 auto gesture2 = AceType::MakeRefPtr<TapGesture>();
1029 auto gesture3 = AceType::MakeRefPtr<TapGesture>();
1030 gestureGroup.AddGesture(gesture);
1031 gestureGroup.AddGesture(gesture2);
1032 gestureGroup.AddGesture(gesture3);
1033
1034 std::vector<RefPtr<Gesture>> gestures;
1035 auto longPressGestureOne = AceType::MakeRefPtr<LongPressGesture>(5, false, 1);
1036 longPressGestureOne->SetTag("HELLO");
1037 gestures.emplace_back(longPressGestureOne);
1038 auto longPressGestureTwo = AceType::MakeRefPtr<LongPressGesture>(5, false, 1);
1039 gestures.emplace_back(longPressGestureTwo);
1040 auto group = AceType::MakeRefPtr<GestureGroup>(GestureMode::Exclusive, gestures);
1041 gestureGroup.AddGesture(group);
1042
1043 gestureGroup.RemoveGesture(gesture2);
1044 EXPECT_TRUE(result);
1045 }
1046
1047 /**
1048 * @tc.name: GestureGroupTestNg005
1049 * @tc.desc: Test GestureGroup RemoveChildrenByTag function
1050 */
1051 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg005, TestSize.Level1)
1052 {
1053 bool result = true;
1054 GestureGroupModelNG gestureGroupModelNG;
1055 gestureGroupModelNG.Create(0);
1056 RefPtr<GestureProcessor> gestureProcessor;
1057 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
1058 auto gestureGroupNG = AceType::DynamicCast<NG::GestureGroup>(gestureProcessor->TopGestureNG());
1059 GestureGroup gestureGroup = GestureGroup(GestureMode::Sequence);
1060
1061 std::vector<RefPtr<Gesture>> gestures;
1062 auto longPressGestureOne = AceType::MakeRefPtr<LongPressGesture>(5, false, 1);
1063 longPressGestureOne->SetTag("HELLO");
1064 gestures.emplace_back(longPressGestureOne);
1065 auto longPressGestureTwo = AceType::MakeRefPtr<LongPressGesture>(5, false, 1);
1066 gestures.emplace_back(longPressGestureTwo);
1067 auto group = AceType::MakeRefPtr<GestureGroup>(GestureMode::Exclusive, gestures);
1068 gestureGroup.AddGesture(group);
1069
1070 gestureGroup.RemoveChildrenByTag("HELLO", result);
1071 EXPECT_TRUE(result);
1072 }
1073
1074 /**
1075 * @tc.name: GestureGroupTestNg006
1076 * @tc.desc: Test Pan_Gesture Deserialize function
1077 */
1078 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg006, TestSize.Level1)
1079 {
1080 PanDirection panDirection;
1081 panDirection.type = PanDirection::RIGHT;
1082 auto panGesture = AceType::MakeRefPtr<PanGesture>(SINGLE_FINGER_NUMBER, panDirection, PAN_DISTANCE);
1083 const char* buff = nullptr;
1084 auto result = panGesture->Deserialize(buff);
1085 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 };
1086 panGesture->Deserialize(buff2);
1087 EXPECT_EQ(result, -1);
1088 }
1089
1090 /**
1091 * @tc.name: GestureGroupTestNg007
1092 * @tc.desc: Test Pan_Gesture Serialize function
1093 */
1094 HWTEST_F(GestureGroupTestNg, GestureGroupTestNg007, TestSize.Level1)
1095 {
1096 PanDirection panDirection;
1097 panDirection.type = PanDirection::RIGHT;
1098 auto panGesture = AceType::MakeRefPtr<PanGesture>(SINGLE_FINGER_NUMBER, panDirection, PAN_DISTANCE);
1099 char* buff = nullptr;
1100 auto result = panGesture->Serialize(buff);
1101 char buff2[320] = { 0, 0, 0, 0, 172 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0, 8 & 0xFF, 0, 0, 0 };
1102 panGesture->Serialize(buff2);
1103 EXPECT_EQ(result, -1);
1104 }
1105 } // namespace OHOS::Ace::NG