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 "test/unittest/core/gestures/gestures_common_test_ng.h"
16
17 using namespace testing;
18 using namespace testing::ext;
19
20 namespace OHOS::Ace::NG {
21 class SequencedRecognizerTestNg : public GesturesCommonTestNg {
22 public:
23 static void SetUpTestSuite();
24 static void TearDownTestSuite();
25 };
26
SetUpTestSuite()27 void SequencedRecognizerTestNg::SetUpTestSuite()
28 {
29 MockPipelineContext::SetUp();
30 }
31
TearDownTestSuite()32 void SequencedRecognizerTestNg::TearDownTestSuite()
33 {
34 MockPipelineContext::TearDown();
35 }
36
37 /**
38 * @tc.name: SequencedRecognizerBatchAdjudicateTest001
39 * @tc.desc: Test SequencedRecognizer function: BatchAdjudicate, and GestureDisposal
40 * @tc.type: FUNC
41 */
42 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerBatchAdjudicateTest001, TestSize.Level1)
43 {
44 /**
45 * @tc.steps: step1. create SequencedRecognizer.
46 */
47 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
48 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
49 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
50
51 /**
52 * @tc.steps: step2. call GestureDisposal function and compare result.
53 * @tc.steps: case1: disposal: ACCEPT, refereeState: SUCCEED
54 * @tc.expected: step2. result equals.
55 */
56 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
57 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
58 sequencedRecognizer->currentIndex_ = -9;
59 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::ACCEPT);
60 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::SUCCEED);
61
62 /**
63 * @tc.steps: step2. call GestureDisposal function and compare result.
64 * @tc.steps: case2: disposal: ACCEPT, refereeState: PENDING, currentIndex = 0
65 * @tc.expected: step2. result equals.
66 */
67 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
68 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
69 sequencedRecognizer->currentIndex_ = -10;
70 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::ACCEPT);
71 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::SUCCEED);
72
73 /**
74 * @tc.steps: step2. call GestureDisposal function and compare result.
75 * @tc.steps: case3: disposal: REJECT, refereeState: FAIL
76 * @tc.expected: step2. result equals.
77 */
78 sequencedRecognizer->refereeState_ = RefereeState::FAIL;
79 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
80 sequencedRecognizer->currentIndex_ = -9;
81 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::REJECT);
82 EXPECT_NE(clickRecognizerPtr->refereeState_, RefereeState::PENDING);
83
84 /**
85 * @tc.steps: step2. call GestureDisposal function and compare result.
86 * @tc.steps: case4: disposal: REJECT, refereeState: SUCCESS, refereeState_ = FAIL
87 * @tc.expected: step2. result equals.
88 */
89 sequencedRecognizer->refereeState_ = RefereeState::FAIL;
90 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
91 sequencedRecognizer->currentIndex_ = -10;
92 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::REJECT);
93 EXPECT_NE(clickRecognizerPtr->refereeState_, RefereeState::PENDING);
94 }
95
96 /**
97 * @tc.name: SequencedRecognizerTest001
98 * @tc.desc: Test SequencedRecognizer function: OnAccepted
99 * @tc.type: FUNC
100 */
101 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest001, TestSize.Level1)
102 {
103 /**
104 * @tc.steps: step1. create SequencedRecognizer.
105 */
106 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
107 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
108
109 /**
110 * @tc.steps: step2. call OnAccepted function and compare result.
111 * @tc.steps: case1: recognizers_ is empty
112 * @tc.expected: step2. result equals.
113 */
114 sequencedRecognizer->OnAccepted();
115 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::SUCCEED);
116
117 /**
118 * @tc.steps: step2. call OnAccepted function and compare result.
119 * @tc.steps: case2: recognizers_ is not empty, have nullptr
120 * @tc.expected: step2. result equals.
121 */
122 sequencedRecognizer->recognizers_.push_back(nullptr);
123 sequencedRecognizer->OnAccepted();
124 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::SUCCEED);
125
126 /**
127 * @tc.steps: step2. call OnAccepted function and compare result.
128 * @tc.steps: case3: recognizers_ is not empty, have click ptr
129 * @tc.expected: step2. result equals.
130 */
131 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
132 sequencedRecognizer->recognizers_.clear();
133 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
134 sequencedRecognizer->OnAccepted();
135 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::SUCCEED);
136 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::SUCCEED);
137 }
138
139 /**
140 * @tc.name: SequencedRecognizerTest002
141 * @tc.desc: Test SequencedRecognizer function: OnRejected
142 * @tc.type: FUNC
143 */
144 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest002, TestSize.Level1)
145 {
146 /**
147 * @tc.steps: step1. create SequencedRecognizer.
148 */
149 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
150 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
151
152 /**
153 * @tc.steps: step2. call OnRejected function and compare result.
154 * @tc.steps: case1: recognizers_ is empty
155 * @tc.expected: step2. result equals.
156 */
157 sequencedRecognizer->OnRejected();
158 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::FAIL);
159
160 /**
161 * @tc.steps: step2. call OnRejected function and compare result.
162 * @tc.steps: case2: recognizers_ is not empty, have nullptr
163 * @tc.expected: step2. result equals.
164 */
165 sequencedRecognizer->currentIndex_ = -1;
166 sequencedRecognizer->recognizers_.push_back(nullptr);
167 sequencedRecognizer->OnRejected();
168 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::FAIL);
169
170 /**
171 * @tc.steps: step2. call OnAccepted function and compare result.
172 * @tc.steps: case3: recognizers_ is not empty, have click ptr
173 * @tc.expected: step2. result equals.
174 */
175 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
176 sequencedRecognizer->currentIndex_ = 0;
177 sequencedRecognizer->recognizers_.clear();
178 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
179 sequencedRecognizer->OnRejected();
180 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::FAIL);
181 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::FAIL);
182 }
183
184 /**
185 * @tc.name: SequencedRecognizerTest003
186 * @tc.desc: Test SequencedRecognizer function: OnPending
187 * @tc.type: FUNC
188 */
189 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest003, TestSize.Level1)
190 {
191 /**
192 * @tc.steps: step1. create SequencedRecognizer.
193 */
194 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
195 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
196
197 /**
198 * @tc.steps: step2. call OnPending function and compare result.
199 * @tc.steps: case1: recognizers_ is empty
200 * @tc.expected: step2. result equals.
201 */
202 sequencedRecognizer->OnPending();
203 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::PENDING);
204
205 /**
206 * @tc.steps: step2. call OnPending function and compare result.
207 * @tc.steps: case2: recognizers_ is not empty, have nullptr
208 * @tc.expected: step2. result equals.
209 */
210 sequencedRecognizer->recognizers_.push_back(nullptr);
211 sequencedRecognizer->OnPending();
212 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::PENDING);
213
214 /**
215 * @tc.steps: step2. call OnPending function and compare result.
216 * @tc.steps: case3: recognizers_ is not empty, have click ptr, ACCEPT
217 * @tc.expected: step2. result equals.
218 */
219 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
220 clickRecognizerPtr->disposal_ = GestureDisposal::ACCEPT;
221 sequencedRecognizer->recognizers_.clear();
222 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
223 sequencedRecognizer->OnPending();
224 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::PENDING);
225 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::SUCCEED);
226
227 /**
228 * @tc.steps: step2. call OnPending function and compare result.
229 * @tc.steps: case4: recognizers_ is not empty, have click ptr, PENDING
230 * @tc.expected: step2. result equals.
231 */
232 clickRecognizerPtr->disposal_ = GestureDisposal::PENDING;
233 sequencedRecognizer->recognizers_.clear();
234 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
235 sequencedRecognizer->OnPending();
236 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::PENDING);
237 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::PENDING);
238 }
239
240 /**
241 * @tc.name: SequencedRecognizerTest004
242 * @tc.desc: Test SequencedRecognizer function: OnBlocked
243 * @tc.type: FUNC
244 */
245 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest004, TestSize.Level1)
246 {
247 /**
248 * @tc.steps: step1. create SequencedRecognizer.
249 */
250 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
251 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
252
253 /**
254 * @tc.steps: step2. call OnBlocked function and compare result.
255 * @tc.steps: case1: recognizers_ is empty
256 * @tc.expected: step2. result equals.
257 */
258 sequencedRecognizer->OnBlocked();
259 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::READY);
260
261 /**
262 * @tc.steps: step2. call OnBlocked function and compare result.
263 * @tc.steps: case2: recognizers_ is not empty, have nullptr
264 * @tc.expected: step2. result equals.
265 */
266 sequencedRecognizer->recognizers_.push_back(nullptr);
267 sequencedRecognizer->OnBlocked();
268 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::READY);
269
270 /**
271 * @tc.steps: step2. call OnBlocked function and compare result.
272 * @tc.steps: case3: recognizers_ is not empty, disposal is ACCEPT
273 * @tc.expected: step2. result equals.
274 */
275 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
276 sequencedRecognizer->disposal_ = GestureDisposal::ACCEPT;
277 sequencedRecognizer->recognizers_.clear();
278 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
279 sequencedRecognizer->OnBlocked();
280 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::SUCCEED_BLOCKED);
281
282 /**
283 * @tc.steps: step2. call OnBlocked function and compare result.
284 * @tc.steps: case4: recognizers_ is not empty, disposal is PENDING
285 * @tc.expected: step2. result equals.
286 */
287 sequencedRecognizer->disposal_ = GestureDisposal::PENDING;
288 sequencedRecognizer->OnBlocked();
289 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::PENDING_BLOCKED);
290
291 /**
292 * @tc.steps: step2. call OnBlocked function and compare result.
293 * @tc.steps: case5: recognizers_ is not empty nullptr, disposal is ACCEPT
294 * @tc.expected: step2. result equals.
295 */
296 sequencedRecognizer->disposal_ = GestureDisposal::ACCEPT;
297 sequencedRecognizer->recognizers_.clear();
298 sequencedRecognizer->recognizers_.push_back(nullptr);
299 sequencedRecognizer->OnBlocked();
300 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::SUCCEED_BLOCKED);
301
302 /**
303 * @tc.steps: step2. call OnBlocked function and compare result.
304 * @tc.steps: case6: recognizers_ is not empty nullptr, disposal is PENDING
305 * @tc.expected: step2. result equals.
306 */
307 sequencedRecognizer->disposal_ = GestureDisposal::PENDING;
308 sequencedRecognizer->OnBlocked();
309 EXPECT_EQ(sequencedRecognizer->refereeState_, RefereeState::PENDING_BLOCKED);
310 }
311
312 /**
313 * @tc.name: SequencedRecognizerTest005
314 * @tc.desc: Test SequencedRecognizer function: HandleEvent
315 * @tc.type: FUNC
316 */
317 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest005, TestSize.Level1)
318 {
319 /**
320 * @tc.steps: step1. create SequencedRecognizer.
321 */
322 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
323 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
324 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
325 sequencedRecognizer->recognizers_.clear();
326 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
327 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
328 bool result = false;
329 TouchEvent touchEvent;
330
331 /**
332 * @tc.steps: step2. call HandleEvent function and compare result.
333 * @tc.steps: case1: currentIndex = 0
334 * @tc.expected: step2. result equals.
335 */
336 result = sequencedRecognizer->HandleEvent(touchEvent);
337 EXPECT_EQ(result, true);
338
339 /**
340 // * @tc.steps: step2. call HandleEvent function and compare result.
341 // * @tc.steps: case2: currentIndex = 1, prevState = SUCCESS
342 // * @tc.expected: step2. result equals.
343 // */
344 sequencedRecognizer->currentIndex_ = 1;
345 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
346 result = sequencedRecognizer->HandleEvent(touchEvent);
347 EXPECT_EQ(result, true);
348
349 /**
350 * @tc.steps: step2. call HandleEvent function and compare result.
351 * @tc.steps: case3: currentIndex = 1, prevState = READY
352 * @tc.expected: step2. result equals.
353 */
354 sequencedRecognizer->currentIndex_ = 1;
355 clickRecognizerPtr->refereeState_ = RefereeState::READY;
356 result = sequencedRecognizer->HandleEvent(touchEvent);
357 EXPECT_EQ(result, true);
358 }
359
360 /**
361 * @tc.name: SequencedRecognizerTest006
362 * @tc.desc: Test SequencedRecognizer function: HandleEvent
363 * @tc.type: FUNC
364 */
365 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest006, TestSize.Level1)
366 {
367 /**
368 * @tc.steps: step1. create SequencedRecognizer.
369 */
370 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
371 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
372 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
373 sequencedRecognizer->recognizers_.clear();
374 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
375 bool result = false;
376 TouchEvent touchEvent;
377
378 /**
379 * @tc.steps: step2. call HandleEvent function and compare result.
380 * @tc.steps: case4: point.type = DOWN, size = 1
381 * @tc.expected: step2. result equals.
382 */
383 touchEvent.type = TouchType::DOWN;
384 result = sequencedRecognizer->HandleEvent(touchEvent);
385 EXPECT_EQ(result, true);
386
387 /**
388 * @tc.steps: step2. call HandleEvent function and compare result.
389 * @tc.steps: case5: point.type = MOVE
390 * @tc.expected: step2. result equals.
391 */
392 touchEvent.type = TouchType::MOVE;
393 result = sequencedRecognizer->HandleEvent(touchEvent);
394 EXPECT_EQ(result, true);
395
396 /**
397 * @tc.steps: step2. call HandleEvent function and compare result.
398 * @tc.steps: case6: point.type = UP
399 * @tc.expected: step2. result equals.
400 */
401 touchEvent.type = TouchType::UP;
402 result = sequencedRecognizer->HandleEvent(touchEvent);
403 EXPECT_EQ(result, true);
404
405 /**
406 * @tc.steps: step2. call HandleEvent function and compare result.
407 * @tc.steps: case7: point.type = CANCEL
408 * @tc.expected: step2. result equals.
409 */
410 touchEvent.type = TouchType::CANCEL;
411 result = sequencedRecognizer->HandleEvent(touchEvent);
412 EXPECT_EQ(result, true);
413 }
414
415 /**
416 * @tc.name: SequencedRecognizerTest007
417 * @tc.desc: Test SequencedRecognizer function: HandleEvent
418 * @tc.type: FUNC
419 */
420 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest007, TestSize.Level1)
421 {
422 /**
423 * @tc.steps: step1. create SequencedRecognizer.
424 */
425 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
426 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
427 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
428 sequencedRecognizer->recognizers_.clear();
429 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
430 bool result = false;
431 TouchEvent touchEvent;
432
433 /**
434 * @tc.steps: step2. call HandleEvent function and compare result.
435 * @tc.steps: case8: point.type = UNKOWN
436 * @tc.expected: step2. result equals.
437 */
438 touchEvent.type = TouchType::UNKNOWN;
439 result = sequencedRecognizer->HandleEvent(touchEvent);
440 EXPECT_EQ(result, true);
441
442 /**
443 * @tc.steps: step2. call HandleEvent function and compare result.
444 * @tc.steps: case9: point.type = UP and refereeState = PENDING
445 * @tc.expected: step2. result equals.
446 */
447 touchEvent.type = TouchType::UP;
448 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
449 result = sequencedRecognizer->HandleEvent(touchEvent);
450 EXPECT_EQ(result, true);
451
452 /**
453 * @tc.steps: step2. call HandleEvent function and compare result.
454 * @tc.steps: case10: point.type != UP and refereeState = PENDING
455 * @tc.expected: step2. result equals.
456 */
457 touchEvent.type = TouchType::DOWN;
458 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
459 result = sequencedRecognizer->HandleEvent(touchEvent);
460 EXPECT_EQ(result, true);
461
462 /**
463 * @tc.steps: step2. call HandleEvent function and compare result.
464 * @tc.steps: case11: point.type = DOWN, size > 1
465 * @tc.expected: step2. result equals.
466 */
467 touchEvent.type = TouchType::DOWN;
468 sequencedRecognizer->touchPoints_[0] = touchEvent;
469 sequencedRecognizer->touchPoints_[1] = touchEvent;
470 result = sequencedRecognizer->HandleEvent(touchEvent);
471 EXPECT_EQ(result, true);
472 }
473
474 /**
475 * @tc.name: SequencedRecognizerTest008
476 * @tc.desc: Test SequencedRecognizer function: BatchAdjudicate, and GestureDisposal
477 * @tc.type: FUNC
478 */
479 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest008, TestSize.Level1)
480 {
481 /**
482 * @tc.steps: step1. create SequencedRecognizer.
483 */
484 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
485 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
486 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
487
488 /**
489 * @tc.steps: step2. call GestureDisposal function and compare result.
490 * @tc.steps: case1: disposal: ACCEPT, refereeState: SUCCEED
491 * @tc.expected: step2. result equals.
492 */
493 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
494 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::ACCEPT);
495 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::SUCCEED);
496
497 /**
498 * @tc.steps: step2. call GestureDisposal function and compare result.
499 * @tc.steps: case2: disposal: ACCEPT, refereeState: PENDING, currentIndex = 0
500 * @tc.expected: step2. result equals.
501 */
502 sequencedRecognizer->currentIndex_ = 0;
503 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
504 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::ACCEPT);
505 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::SUCCEED);
506
507 /**
508 * @tc.steps: step2. call GestureDisposal function and compare result.
509 * @tc.steps: case3: disposal: REJECT, refereeState: FAIL
510 * @tc.expected: step2. result equals.
511 */
512 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
513 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::REJECT);
514 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::FAIL);
515
516 /**
517 * @tc.steps: step2. call GestureDisposal function and compare result.
518 * @tc.steps: case4: disposal: REJECT, refereeState: SUCCESS, refereeState_ = FAIL
519 * @tc.expected: step2. result equals.
520 */
521 sequencedRecognizer->refereeState_ = RefereeState::FAIL;
522 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
523 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::REJECT);
524 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::FAIL);
525
526 /**
527 * @tc.steps: step2. call GestureDisposal function and compare result.
528 * @tc.steps: case5: disposal: PENDING, refereeState: PENDING
529 * @tc.expected: step2. result equals.
530 */
531 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
532 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::PENDING);
533 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::PENDING);
534
535 /**
536 * @tc.steps: step2. call GestureDisposal function and compare result.
537 * @tc.steps: case5: disposal: PENDING, refereeState: SUCCESS, refereeState_: PENDING
538 * @tc.expected: step2. result equals.
539 */
540 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
541 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
542 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, GestureDisposal::PENDING);
543 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::PENDING);
544 }
545
546 /**
547 * @tc.name: SequencedRecognizerHandleOverdueDeadlineTest001
548 * @tc.desc: Test SequencedRecognizer function: HandleOverdueDeadline
549 * @tc.type: FUNC
550 */
551 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerHandleOverdueDeadlineTest001, TestSize.Level1)
552 {
553 /**
554 * @tc.steps: step1. create SequencedRecognizer.
555 */
556 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
557 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
558 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
559
560 /**
561 * @tc.steps: step2. call UpdateCurrentIndex function and compare result.
562 * @tc.steps: case1: currentIndex != size - 1
563 * @tc.expected: step2. result equals.
564 */
565 sequencedRecognizer->currentIndex_ = 0;
566 sequencedRecognizer->refereeState_ = RefereeState::SUCCEED;
567 sequencedRecognizer->HandleOverdueDeadline();
568 EXPECT_EQ(sequencedRecognizer->currentIndex_, 0);
569 }
570
571 /**
572 * @tc.name: SequencedRecognizerTest009
573 * @tc.desc: Test SequencedRecognizer function: UpdateCurrentIndex
574 * @tc.type: FUNC
575 */
576 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest009, TestSize.Level1)
577 {
578 /**
579 * @tc.steps: step1. create SequencedRecognizer.
580 */
581 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
582 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
583 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
584
585 /**
586 * @tc.steps: step2. call UpdateCurrentIndex function and compare result.
587 * @tc.steps: case1: currentIndex == size - 1
588 * @tc.expected: step2. result equals.
589 */
590 sequencedRecognizer->currentIndex_ = -1;
591 sequencedRecognizer->UpdateCurrentIndex();
592 EXPECT_EQ(sequencedRecognizer->currentIndex_, -1);
593
594 /**
595 * @tc.steps: step2. call UpdateCurrentIndex function and compare result.
596 * @tc.steps: case1: currentIndex != size - 1
597 * @tc.expected: step2. result equals.
598 */
599 sequencedRecognizer->currentIndex_ = 0;
600 sequencedRecognizer->UpdateCurrentIndex();
601 EXPECT_EQ(sequencedRecognizer->currentIndex_, 1);
602 }
603
604 /**
605 * @tc.name: SequencedRecognizerTest010
606 * @tc.desc: Test SequencedRecognizer function: ReconcileFrom
607 * @tc.type: FUNC
608 */
609 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest010, TestSize.Level1)
610 {
611 /**
612 * @tc.steps: step1. create SwipeRecognizer.
613 */
614 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
615 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
616 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
617 bool result = false;
618
619 /**
620 * @tc.steps: step2. call ReconcileFrom function
621 * @tc.steps: case1: recognizer is nullptr
622 * @tc.expected: step2. result equals.
623 */
624 result = sequencedRecognizer->ReconcileFrom(nullptr);
625 EXPECT_EQ(result, false);
626
627 /**
628 * @tc.steps: step2. call ReconcileFrom function
629 * @tc.steps: case2: size not same, priorityMask not same
630 * @tc.expected: step2. result equals.
631 */
632 sequencedRecognizer->recognizers_.clear();
633 sequencedRecognizer->recognizers_.push_back(nullptr);
634 sequencedRecognizer->priorityMask_ = GestureMask::Begin;
635 result = sequencedRecognizer->ReconcileFrom(sequencedRecognizerPtr);
636 EXPECT_EQ(result, false);
637
638 /**
639 * @tc.steps: step2. call ReconcileFrom function
640 * @tc.steps: case3: size not same, priorityMask same
641 * @tc.expected: step2. result equals.
642 */
643 sequencedRecognizer->recognizers_.clear();
644 sequencedRecognizer->recognizers_.push_back(nullptr);
645 sequencedRecognizer->priorityMask_ = GestureMask::Normal;
646 result = sequencedRecognizer->ReconcileFrom(sequencedRecognizerPtr);
647 EXPECT_EQ(result, false);
648
649 /**
650 * @tc.steps: step2. call ReconcileFrom function
651 * @tc.steps: case4: size same, priorityMask not same
652 * @tc.expected: step2. result equals.
653 */
654 sequencedRecognizer->recognizers_.clear();
655 sequencedRecognizer->priorityMask_ = GestureMask::Begin;
656 result = sequencedRecognizer->ReconcileFrom(sequencedRecognizerPtr);
657 EXPECT_EQ(result, false);
658
659 /**
660 * @tc.steps: step2. call ReconcileFrom function
661 * @tc.steps: case4: size same, priorityMask same, child is nullptr
662 * @tc.expected: step2. result equals.
663 */
664 sequencedRecognizer->recognizers_.clear();
665 sequencedRecognizer->recognizers_.push_back(nullptr);
666 sequencedRecognizerPtr->recognizers_.clear();
667 sequencedRecognizerPtr->recognizers_.push_back(nullptr);
668 sequencedRecognizer->priorityMask_ = GestureMask::Normal;
669 result = sequencedRecognizer->ReconcileFrom(sequencedRecognizerPtr);
670 EXPECT_EQ(result, false);
671
672 /**
673 * @tc.steps: step2. call ReconcileFrom function
674 * @tc.steps: case4: size same, priorityMask same, child is ptr
675 * @tc.expected: step2. result equals.
676 */
677 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
678 sequencedRecognizer->recognizers_.clear();
679 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
680 sequencedRecognizerPtr->recognizers_.clear();
681 sequencedRecognizerPtr->recognizers_.push_back(clickRecognizerPtr);
682 sequencedRecognizer->priorityMask_ = GestureMask::Normal;
683 result = sequencedRecognizer->ReconcileFrom(sequencedRecognizerPtr);
684 EXPECT_EQ(result, true);
685
686 /**
687 * @tc.steps: step2. call ReconcileFrom function
688 * @tc.steps: case4: size same, priorityMask same, child is ptr and nullptr
689 * @tc.expected: step2. result equals.
690 */
691 sequencedRecognizer->recognizers_.clear();
692 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
693 sequencedRecognizerPtr->recognizers_.clear();
694 sequencedRecognizerPtr->recognizers_.push_back(nullptr);
695 sequencedRecognizer->priorityMask_ = GestureMask::Normal;
696 result = sequencedRecognizer->ReconcileFrom(sequencedRecognizerPtr);
697 EXPECT_EQ(result, false);
698 }
699
700 /**
701 * @tc.name: SequencedRecognizerTest011
702 * @tc.desc: Test HandleEvent
703 * @tc.type: FUNC
704 */
705 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest011, TestSize.Level1)
706 {
707 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
708 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
709 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
710 AxisEvent point;
711 point.action = AxisAction::BEGIN;
712 auto result = sequencedRecognizerPtr->HandleEvent(point);
713 EXPECT_EQ(result, true);
714 point.action = AxisAction::UPDATE;
715 result = sequencedRecognizerPtr->HandleEvent(point);
716 EXPECT_EQ(result, true);
717 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
718 sequencedRecognizer->recognizers_.clear();
719 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
720 result = sequencedRecognizerPtr->HandleEvent(point);
721 EXPECT_EQ(result, true);
722 sequencedRecognizer->recognizers_.clear();
723 sequencedRecognizer->recognizers_.push_back(nullptr);
724 result = sequencedRecognizerPtr->HandleEvent(point);
725 EXPECT_EQ(result, true);
726 sequencedRecognizer->currentIndex_ = 0;
727 sequencedRecognizer->recognizers_.clear();
728 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
729 result = sequencedRecognizerPtr->HandleEvent(point);
730 EXPECT_EQ(result, true);
731 sequencedRecognizer->currentIndex_ = 2;
732 sequencedRecognizer->recognizers_.clear();
733 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
734 result = sequencedRecognizerPtr->HandleEvent(point);
735 EXPECT_EQ(result, true);
736 }
737
738 /**
739 * @tc.name: SequencedRecognizerTest012
740 * @tc.desc: Test HandleEvent
741 * @tc.type: FUNC
742 */
743 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest012, TestSize.Level1)
744 {
745 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
746 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
747 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
748 AxisEvent point;
749 point.action = AxisAction::NONE;
750 auto result = sequencedRecognizerPtr->HandleEvent(point);
751 EXPECT_EQ(result, true);
752 sequencedRecognizerPtr->refereeState_ = RefereeState::PENDING;
753 point.action = AxisAction::END;
754 result = sequencedRecognizerPtr->HandleEvent(point);
755 EXPECT_EQ(result, true);
756 sequencedRecognizerPtr->refereeState_ = RefereeState::PENDING;
757 point.action = AxisAction::UPDATE;
758 result = sequencedRecognizerPtr->HandleEvent(point);
759 EXPECT_EQ(result, true);
760 sequencedRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
761 point.action = AxisAction::END;
762 result = sequencedRecognizerPtr->HandleEvent(point);
763 EXPECT_EQ(result, true);
764 }
765
766 /**
767 * @tc.name: SequencedRecognizerTest013
768 * @tc.desc: Test CleanRecognizerState
769 * @tc.type: FUNC
770 */
771 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest013, TestSize.Level1)
772 {
773 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
774 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
775 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
776 AxisEvent point;
777 point.action = AxisAction::NONE;
778 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
779 sequencedRecognizer->recognizers_.clear();
780 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
781 sequencedRecognizer->CleanRecognizerState();
782 sequencedRecognizer->refereeState_ = RefereeState::SUCCEED;
783 sequencedRecognizer->currentFingers_ = 0;
784 sequencedRecognizer->CleanRecognizerState();
785 sequencedRecognizer->refereeState_ = RefereeState::FAIL;
786 sequencedRecognizer->currentFingers_ = 0;
787 sequencedRecognizer->CleanRecognizerState();
788 sequencedRecognizer->refereeState_ = RefereeState::DETECTING;
789 sequencedRecognizer->currentFingers_ = 0;
790 sequencedRecognizer->CleanRecognizerState();
791 sequencedRecognizer->refereeState_ = RefereeState::SUCCEED_BLOCKED;
792 sequencedRecognizer->currentFingers_ = 0;
793 sequencedRecognizer->CleanRecognizerState();
794 sequencedRecognizer->refereeState_ = RefereeState::FAIL;
795 sequencedRecognizer->currentFingers_ = 1;
796 sequencedRecognizer->CleanRecognizerState();
797 sequencedRecognizer->recognizers_.clear();
798 sequencedRecognizer->CleanRecognizerState();
799 EXPECT_EQ(sequencedRecognizerPtr->currentIndex_, 0);
800 }
801
802 /**
803 * @tc.name: SequencedRecognizerTest014
804 * @tc.desc: Test ForceCleanRecognizer
805 * @tc.type: FUNC
806 */
807 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest014, TestSize.Level1)
808 {
809 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
810 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
811 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
812 AxisEvent point;
813 point.action = AxisAction::NONE;
814 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
815 sequencedRecognizer->recognizers_.clear();
816 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
817 sequencedRecognizer->ForceCleanRecognizer();
818 EXPECT_EQ(sequencedRecognizerPtr->currentIndex_, 0);
819 }
820
821 /**
822 * @tc.name: SequencedRecognizerTest015
823 * @tc.desc: Test ForceCleanRecognizer
824 * @tc.type: FUNC
825 */
826 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest015, TestSize.Level1)
827 {
828 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
829 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
830 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
831 AxisEvent point;
832 point.action = AxisAction::NONE;
833 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
834 sequencedRecognizer->recognizers_.clear();
835 sequencedRecognizer->ForceCleanRecognizer();
836 EXPECT_EQ(sequencedRecognizerPtr->currentIndex_, 0);
837 }
838
839 /**
840 * @tc.name: SequencedRecognizerTest016
841 * @tc.desc: Test CleanRecognizerState
842 * @tc.type: FUNC
843 */
844 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest016, TestSize.Level1)
845 {
846 /**
847 * @tc.steps: step1. create ExclusiveRecognizer.
848 */
849 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
850 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {clickRecognizerPtr};
851 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
852
853 /**
854 * @tc.steps: step3. set child recognizer state and call cleanRecognizerState function and compare result.
855 * @tc.steps: case1: touchPoints size is 1, clean success.
856 * @tc.expected: step3. clickRecognizer state set ready.
857 */
858 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
859 sequencedRecognizer->CleanRecognizerState();
860 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::READY);
861
862 /**
863 * @tc.steps: step3. set child recognizer state and call cleanRecognizerState function and compare result.
864 * @tc.steps: case2: touchPoints size is 2, clean fail.
865 * @tc.expected: step3. clickRecognizer state set ready.
866 */
867 clickRecognizerPtr->touchPoints_[0] = {};
868 clickRecognizerPtr->touchPoints_[1] = {};
869 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
870 sequencedRecognizer->CleanRecognizerState();
871 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::SUCCEED);
872 }
873
874 /**
875 * @tc.name: SequencedRecognizerTest017
876 * @tc.desc: Test SendCallbackMsg
877 * @tc.type: FUNC
878 */
879 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest017, TestSize.Level1)
880 {
881 /**
882 * @tc.steps: step1. create SequencedRecognizer.
883 */
884 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
885 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
886
887 /**
888 * @tc.steps: step2. call SendCallbackMsg function and compare result.
889 * @tc.steps: case1: onAction is no, *onAction is no.
890 * @tc.expected: step2. result equals.
891 */
892 std::unique_ptr<GestureEventFunc> onAction;
893 sequencedRecognizer->SendCallbackMsg(onAction);
894 EXPECT_EQ(sequencedRecognizer->touchPoints_.size(), 0);
895
896 /**
897 * @tc.steps: step2. call SendCallbackMsg function and compare result.
898 * @tc.steps: case2: onAction is yes, *onAction is no.
899 * @tc.expected: step2. result equals.
900 */
901 sequencedRecognizer->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
902 onAction = std::make_unique<GestureEventFunc>();
903 sequencedRecognizer->SendCallbackMsg(onAction);
904 EXPECT_EQ(sequencedRecognizer->touchPoints_.size(), 0);
905
906 /**
907 * @tc.steps: step2. call SendCallbackMsg function and compare result.
908 * @tc.steps: case3: onAction is yes, *onAction is yes, disposeTag_ is false.
909 * @tc.expected: step2. result equals.
910 */
__anon6567a2580102(GestureEvent) 911 onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
912 sequencedRecognizer->SendCallbackMsg(onAction);
913 EXPECT_EQ(sequencedRecognizer->touchPoints_.size(), 0);
914
915 /**
916 * @tc.steps: step2. call SendCallbackMsg function and compare result.
917 * @tc.steps: case4: onAction is yes, *onAction is yes, disposeTag_ is true.
918 * @tc.expected: step2. result equals.
919 */
920 sequencedRecognizer->gestureInfo_->SetDisposeTag(true);
921 sequencedRecognizer->SendCallbackMsg(onAction);
922 EXPECT_EQ(sequencedRecognizer->touchPoints_.size(), 0);
923 }
924
925 /**
926 * @tc.name: SequencedRecognizerTest018
927 * @tc.desc: Test CheckGroupState
928 * @tc.type: FUNC
929 */
930 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest018, TestSize.Level1)
931 {
932 /**
933 * @tc.steps: step1. create SequencedRecognizer.
934 */
935 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
936 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
937
938 /**
939 * @tc.steps: step2. call CheckGroupState function and compare result.
940 * @tc.steps: case1: currentIndex_ is -1.
941 * @tc.expected: step2. result is false.
942 */
943 sequencedRecognizer->currentIndex_ = -1;
944 bool result = sequencedRecognizer->CheckGroupState();
945 EXPECT_FALSE(result);
946
947 /**
948 * @tc.steps: step2. call CheckGroupState function and compare result.
949 * @tc.steps: case2: currentIndex_ is 0.
950 * @tc.expected: step2. result is false.
951 */
952 sequencedRecognizer->currentIndex_ = 0;
953 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
954 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
955 result = sequencedRecognizer->CheckGroupState();
956 EXPECT_FALSE(result);
957
958 /**
959 * @tc.steps: step2. call CheckGroupState function and compare result.
960 * @tc.steps: case3: refereeState_ is RefereeState::PENDING.
961 * @tc.expected: step2. result is true.
962 */
963 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
964 result = sequencedRecognizer->CheckGroupState();
965 EXPECT_TRUE(result);
966 }
967
968 /**
969 * @tc.name: SequencedRecognizerTest019
970 * @tc.desc: Test CheckStates
971 * @tc.type: FUNC
972 */
973 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest019, TestSize.Level1)
974 {
975 /**
976 * @tc.steps: step1. create SequencedRecognizer.
977 */
978 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
979 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
980
981 /**
982 * @tc.steps: step2. call CheckStates function and compare result.
983 * @tc.steps: case1: currentIndex_ is -1.
984 * @tc.expected: step2. result is equal to RefereeState::READY.
985 */
986 size_t touchId = 100;
987 sequencedRecognizer->currentIndex_ = -1;
988 RefereeState result = sequencedRecognizer->CheckStates(touchId);
989 EXPECT_EQ(result, RefereeState::READY);
990
991 /**
992 * @tc.steps: step2. call CheckStates function and compare result.
993 * @tc.steps: case2: currentIndex_ is 0.
994 * @tc.expected: step2. result is equal to RefereeState::READY.
995 */
996 sequencedRecognizer->currentIndex_ = 0;
997 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
998 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
999 result = sequencedRecognizer->CheckStates(touchId);
1000 EXPECT_EQ(result, RefereeState::READY);
1001
1002 /**
1003 * @tc.steps: step2. call CheckStates function and compare result.
1004 * @tc.steps: case3: refereeState_ is RefereeState::PENDING.
1005 * @tc.expected: step2. result is equal to RefereeState::PENDING.
1006 */
1007 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
1008 result = sequencedRecognizer->CheckStates(touchId);
1009 EXPECT_EQ(result, RefereeState::PENDING);
1010 }
1011
1012 /**
1013 * @tc.name: SequencedRecognizerTest020
1014 * @tc.desc: Test HandleEvent
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest020, TestSize.Level1)
1018 {
1019 /**
1020 * @tc.steps: step1. create SequencedRecognizer.
1021 */
1022 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1023 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1024
1025 /**
1026 * @tc.steps: step2. call HandleEvent function and compare result.
1027 * @tc.steps: case1: currentIndex_ is 0.
1028 * @tc.expected: step2. result is true.
1029 */
1030 AxisEvent point;
1031 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1032 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
1033 bool result = sequencedRecognizer->HandleEvent(point);
1034 EXPECT_TRUE(result);
1035
1036 /**
1037 * @tc.steps: step2. call HandleEvent function and compare result.
1038 * @tc.steps: case2: action is AxisAction::NONE.
1039 * @tc.expected: step2. result is true.
1040 */
1041 point.action = AxisAction::NONE;
1042 result = sequencedRecognizer->HandleEvent(point);
1043 EXPECT_TRUE(result);
1044
1045 /**
1046 * @tc.steps: step2. call HandleEvent function and compare result.
1047 * @tc.steps: case3: action is AxisAction::END.
1048 * @tc.expected: step2. result is true.
1049 */
1050 point.action = AxisAction::END;
1051 result = sequencedRecognizer->HandleEvent(point);
1052 EXPECT_TRUE(result);
1053
1054 /**
1055 * @tc.steps: step2. call HandleEvent function and compare result.
1056 * @tc.steps: case4: refereeState_ is RefereeState::PENDING.
1057 * @tc.expected: step2. result is true.
1058 */
1059 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
1060 result = sequencedRecognizer->HandleEvent(point);
1061 EXPECT_TRUE(result);
1062 }
1063
1064 /**
1065 * @tc.name: SequencedRecognizerTest021
1066 * @tc.desc: Test HandleEvent
1067 * @tc.type: FUNC
1068 */
1069 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest021, TestSize.Level1)
1070 {
1071 /**
1072 * @tc.steps: step1. create SequencedRecognizer.
1073 */
1074 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1075 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1076
1077 /**
1078 * @tc.steps: step2. call HandleEvent function and compare result.
1079 * @tc.steps: case1: currentIndex_ is 1.
1080 * @tc.expected: step2. result is true.
1081 */
1082 AxisEvent point;
1083 RefPtr<ClickRecognizer> clickRecognizerPtr1 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1084 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1085 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr1);
1086 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr2);
1087 sequencedRecognizer->currentIndex_ = 1;
1088 bool result = sequencedRecognizer->HandleEvent(point);
1089 EXPECT_TRUE(result);
1090
1091 /**
1092 * @tc.steps: step2. call HandleEvent function and compare result.
1093 * @tc.steps: case2: clickRecognizerPtr2->refereeState_ is RefereeState::PENDING.
1094 * @tc.expected: step2. result is true.
1095 */
1096 clickRecognizerPtr2->refereeState_ = RefereeState::PENDING;
1097 result = sequencedRecognizer->HandleEvent(point);
1098 EXPECT_TRUE(result);
1099 }
1100
1101 /**
1102 * @tc.name: SequencedRecognizerTest022
1103 * @tc.desc: Test UpdateCurrentIndex
1104 * @tc.type: FUNC
1105 */
1106 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest022, TestSize.Level1)
1107 {
1108 /**
1109 * @tc.steps: step1. create SequencedRecognizer.
1110 */
1111 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1112 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1113
1114 /**
1115 * @tc.steps: step2. call UpdateCurrentIndex function and compare result.
1116 * @tc.steps: case1: inputEventType_ is InputEventType::MOUSE_BUTTON.
1117 * @tc.expected: step2. result equals.
1118 */
1119 sequencedRecognizer->currentIndex_ = 0;
1120 sequencedRecognizer->inputEventType_ = InputEventType::MOUSE_BUTTON;
1121 RefPtr<ClickRecognizer> clickRecognizerPtr1 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1122 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1123 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr1);
1124 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr2);
1125 sequencedRecognizer->UpdateCurrentIndex();
1126 EXPECT_EQ(sequencedRecognizer->currentIndex_, 1);
1127
1128 /**
1129 * @tc.steps: step2. call UpdateCurrentIndex function and compare result.
1130 * @tc.steps: case2: isEventHandoverNeeded_ is true.
1131 * @tc.expected: step2. result equals.
1132 */
1133 sequencedRecognizer->currentIndex_ = 0;
1134 sequencedRecognizer->isEventHandoverNeeded_ = true;
1135 sequencedRecognizer->UpdateCurrentIndex();
1136 EXPECT_EQ(sequencedRecognizer->currentIndex_, 1);
1137
1138 /**
1139 * @tc.steps: step2. call UpdateCurrentIndex function and compare result.
1140 * @tc.steps: case3: isEventHandoverNeeded_ is false.
1141 * @tc.expected: step2. result equals.
1142 */
1143 sequencedRecognizer->recognizers_.clear();
1144 sequencedRecognizer->currentIndex_ = 0;
1145 sequencedRecognizer->isEventHandoverNeeded_ = false;
1146 RefPtr<LongPressRecognizer> longPressRecognizer1 =
1147 AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION, FINGER_NUMBER, false);
1148 RefPtr<LongPressRecognizer> longPressRecognizer2 =
1149 AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION, FINGER_NUMBER, false);
1150 sequencedRecognizer->recognizers_.push_back(longPressRecognizer1);
1151 sequencedRecognizer->recognizers_.push_back(longPressRecognizer2);
1152 sequencedRecognizer->UpdateCurrentIndex();
1153 EXPECT_EQ(sequencedRecognizer->currentIndex_, 1);
1154 }
1155
1156 /**
1157 * @tc.name: SequencedRecognizerTest023
1158 * @tc.desc: Test CheckBetweenTwoLongPressRecognizer
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest023, TestSize.Level1)
1162 {
1163 /**
1164 * @tc.steps: step1. create SequencedRecognizer.
1165 */
1166 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1167 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1168
1169 /**
1170 * @tc.steps: step2. call CheckBetweenTwoLongPressRecognizer function and compare result.
1171 * @tc.steps: case1: currentIndex_ is 2.
1172 * @tc.expected: step2. result is false.
1173 */
1174 sequencedRecognizer->currentIndex_ = 2;
1175 RefPtr<LongPressRecognizer> longPressRecognizer1 =
1176 AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION, FINGER_NUMBER, false);
1177 RefPtr<LongPressRecognizer> longPressRecognizer2 =
1178 AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION, FINGER_NUMBER, false);
1179 sequencedRecognizer->recognizers_.push_back(longPressRecognizer1);
1180 sequencedRecognizer->recognizers_.push_back(longPressRecognizer2);
1181 int32_t currentIndex = 1;
1182 bool result = sequencedRecognizer->CheckBetweenTwoLongPressRecognizer(currentIndex);
1183 EXPECT_FALSE(result);
1184
1185 /**
1186 * @tc.steps: step2. call CheckBetweenTwoLongPressRecognizer function and compare result.
1187 * @tc.steps: case2: currentIndex_ is -1.
1188 * @tc.expected: step2. result is false.
1189 */
1190 currentIndex = -1;
1191 result = sequencedRecognizer->CheckBetweenTwoLongPressRecognizer(currentIndex);
1192 EXPECT_FALSE(result);
1193 }
1194
1195 /**
1196 * @tc.name: SequencedRecognizerTest024
1197 * @tc.desc: Test CheckAndSetRecognizerCleanFlag
1198 * @tc.type: FUNC
1199 */
1200 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest024, TestSize.Level1)
1201 {
1202 /**
1203 * @tc.steps: step1. create SequencedRecognizer.
1204 */
1205 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1206 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1207
1208 /**
1209 * @tc.steps: step2. call CheckAndSetRecognizerCleanFlag function and compare result.
1210 * @tc.steps: case1: currentIndex_ is -1.
1211 * @tc.expected: step2. isNeedResetRecognizerState_ is false.
1212 */
1213 RefPtr<NGGestureRecognizer> recognizer = nullptr;
1214 sequencedRecognizer->CheckAndSetRecognizerCleanFlag(recognizer);
1215 EXPECT_FALSE(sequencedRecognizer->IsNeedResetRecognizerState());
1216
1217 /**
1218 * @tc.steps: step2. call CheckAndSetRecognizerCleanFlag function and compare result.
1219 * @tc.steps: case1: currentIndex_ is -1.
1220 * @tc.expected: step2. isNeedResetRecognizerState_ is true.
1221 */
1222 sequencedRecognizer->currentIndex_ = -1;
1223 sequencedRecognizer->CheckAndSetRecognizerCleanFlag(recognizer);
1224 EXPECT_TRUE(sequencedRecognizer->IsNeedResetRecognizerState());
1225 }
1226
1227 /**
1228 * @tc.name: SequencedRecognizerTest025
1229 * @tc.desc: Test CleanRecognizerStateVoluntarily
1230 * @tc.type: FUNC
1231 */
1232 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest025, TestSize.Level1)
1233 {
1234 /**
1235 * @tc.steps: step1. create SequencedRecognizer.
1236 */
1237 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1238 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1239 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1240 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1241
1242 /**
1243 * @tc.steps: step2. call CleanRecognizerStateVoluntarily function and compare result.
1244 * @tc.steps: case1: recognizers_ is not empty nullptr.
1245 * @tc.expected: step2. isNeedResetRecognizerState_ is false.
1246 */
1247 sequencedRecognizer->recognizers_.push_back(nullptr);
1248 sequencedRecognizer->recognizers_.push_back(sequencedRecognizerPtr);
1249 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
1250 sequencedRecognizer->CleanRecognizerStateVoluntarily();
1251 EXPECT_FALSE(sequencedRecognizer->IsNeedResetRecognizerState());
1252
1253 /**
1254 * @tc.steps: step2. call CleanRecognizerStateVoluntarily function and compare result.
1255 * @tc.steps: case2: isNeedResetRecognizerState_ is true.
1256 * @tc.expected: step2. isNeedResetRecognizerState_ is false.
1257 */
1258 sequencedRecognizer->recognizers_.clear();
1259 sequencedRecognizer->SetIsNeedResetRecognizer(true);
1260 sequencedRecognizer->CleanRecognizerStateVoluntarily();
1261 EXPECT_FALSE(sequencedRecognizer->IsNeedResetRecognizerState());
1262 }
1263
1264 /**
1265 * @tc.name: SequencedRecognizerTest026
1266 * @tc.desc: Test ForceCleanRecognizer
1267 * @tc.type: FUNC
1268 */
1269 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest026, TestSize.Level1)
1270 {
1271 /**
1272 * @tc.steps: step1. create SequencedRecognizer.
1273 */
1274 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1275 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1276
1277 /**
1278 * @tc.steps: step2. call ForceCleanRecognizer function and compare result.
1279 * @tc.steps: case: recognizers_ is not empty, have nullptr.
1280 * @tc.expected: step2. currentIndex_ is equal to 0.
1281 */
1282 sequencedRecognizer->recognizers_.push_back(nullptr);
1283 sequencedRecognizer->ForceCleanRecognizer();
1284 EXPECT_EQ(sequencedRecognizer->currentIndex_, 0);
1285 }
1286
1287 /**
1288 * @tc.name: SequencedRecognizerTest027
1289 * @tc.desc: Test NeedStartDeadlineTimerInner
1290 * @tc.type: FUNC
1291 */
1292 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest027, TestSize.Level1)
1293 {
1294 /**
1295 * @tc.steps: step1. create SequencedRecognizer.
1296 */
1297 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1298 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1299 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1300
1301 /**
1302 * @tc.steps: step2. call NeedStartDeadlineTimerInner function and compare result.
1303 * @tc.steps: case: currentIndex_ is 1.
1304 * @tc.expected: step2. result is true.
1305 */
1306 SourceTool sourceTool = SourceTool::UNKNOWN;
1307 sequencedRecognizer->currentIndex_ = 1;
1308 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
1309 bool result = sequencedRecognizer->NeedStartDeadlineTimerInner(clickRecognizerPtr, sourceTool);
1310 EXPECT_TRUE(result);
1311 }
1312
1313 /**
1314 * @tc.name: SequencedRecognizerTest028
1315 * @tc.desc: Test HandleEvent
1316 * @tc.type: FUNC
1317 */
1318 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest028, TestSize.Level1)
1319 {
1320 /**
1321 * @tc.steps: step1. create SequencedRecognizer.
1322 */
1323 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1324 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1325 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1326
1327 /**
1328 * @tc.steps: step2. call HandleEvent function and compare result.
1329 * @tc.steps: case1: recognizers_ is not empty, have nullptr.
1330 * @tc.expected: step2. result is true.
1331 */
1332 TouchEvent point;
1333 sequencedRecognizer->recognizers_.push_back(nullptr);
1334 bool result = sequencedRecognizer->HandleEvent(point);
1335 EXPECT_TRUE(result);
1336
1337 /**
1338 * @tc.steps: step2. call HandleEvent function and compare result.
1339 * @tc.steps: case2: point.type is TouchType::DOWN.
1340 * @tc.expected: step2. result is true.
1341 */
1342 point.type = TouchType::DOWN;
1343 result = sequencedRecognizer->HandleEvent(point);
1344 EXPECT_TRUE(result);
1345
1346 /**
1347 * @tc.steps: step2. call HandleEvent function and compare result.
1348 * @tc.steps: case3: point.childTouchTestListis not empty.
1349 * @tc.expected: step2. result equals.
1350 */
1351 std::string childTouchTest = "childTouchTest";
1352 point.childTouchTestList.push_back(childTouchTest);
1353 sequencedRecognizer->recognizers_.clear();
1354 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
1355 result = sequencedRecognizer->HandleEvent(point);
1356 EXPECT_EQ(sequencedRecognizer->childTouchTestList_, point.childTouchTestList);
1357 EXPECT_TRUE(result);
1358 }
1359
1360 /**
1361 * @tc.name: SequencedRecognizerTest029
1362 * @tc.desc: Test BatchAdjudicate
1363 * @tc.type: FUNC
1364 */
1365 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest029, TestSize.Level1)
1366 {
1367 /**
1368 * @tc.steps: step1. create SequencedRecognizer.
1369 */
1370 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1371 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1372 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1373
1374 /**
1375 * @tc.steps: step2. call BatchAdjudicate function and compare result.
1376 * @tc.steps: case1: disposal: ACCEPT.
1377 * @tc.expected: step2. result equals.
1378 */
1379 GestureDisposal disposal = GestureDisposal::ACCEPT;
1380 sequencedRecognizer->recognizers_.push_back(clickRecognizerPtr);
1381 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, disposal);
1382 EXPECT_EQ(sequencedRecognizer->disposal_, GestureDisposal::ACCEPT);
1383
1384 /**
1385 * @tc.steps: step2. call BatchAdjudicate function and compare result.
1386 * @tc.steps: case2: disposal: ACCEPT, refereeState: READY.
1387 * @tc.expected: step2. result equals.
1388 */
1389 sequencedRecognizer->recognizers_.clear();
1390 clickRecognizerPtr->refereeState_ = RefereeState::READY;
1391 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, disposal);
1392 EXPECT_EQ(sequencedRecognizer->disposal_, GestureDisposal::PENDING);
1393
1394 /**
1395 * @tc.steps: step2. call BatchAdjudicate function and compare result.
1396 * @tc.steps: case3: disposal: REJECT.
1397 * @tc.expected: step2. result equals.
1398 */
1399 disposal = GestureDisposal::REJECT;
1400 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, disposal);
1401 EXPECT_EQ(sequencedRecognizer->disposal_, GestureDisposal::REJECT);
1402
1403 /**
1404 * @tc.steps: step2. call BatchAdjudicate function and compare result.
1405 * @tc.steps: case4: disposal: NONE.
1406 * @tc.expected: step2. result equals.
1407 */
1408 disposal = GestureDisposal::NONE;
1409 sequencedRecognizer->BatchAdjudicate(clickRecognizerPtr, disposal);
1410 EXPECT_EQ(sequencedRecognizer->disposal_, GestureDisposal::PENDING);
1411 }
1412
1413 /**
1414 * @tc.name: SequencedRecognizerTest030
1415 * @tc.desc: Test SendTouchEventToNextRecognizer
1416 * @tc.type: FUNC
1417 */
1418 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest030, TestSize.Level1)
1419 {
1420 /**
1421 * @tc.steps: step1. create SequencedRecognizer.
1422 */
1423 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1424 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1425 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1426 TouchEvent touchEvent;
1427 std::string childTouchTest = "childTouchTest";
1428
1429 /**
1430 * @tc.steps: step2. call SendTouchEventToNextRecognizer function and compare result.
1431 * @tc.steps: case1: inputEventType_ is InputEventType::AXIS.
1432 * @tc.expected: step2. result equals.
1433 */
1434 int64_t beforeDuration = 0;
1435 sequencedRecognizer->inputEventType_ = InputEventType::AXIS;
1436 sequencedRecognizer->SendTouchEventToNextRecognizer(clickRecognizerPtr, beforeDuration);
1437 EXPECT_EQ(clickRecognizerPtr->inputEventType_, InputEventType::AXIS);
1438
1439 /**
1440 * @tc.steps: step2. call SendTouchEventToNextRecognizer function and compare result.
1441 * @tc.steps: case2: inputEventType_ is InputEventType::TOUCH_SCREEN.
1442 * @tc.expected: step2. result equals.
1443 */
1444 beforeDuration = 1;
1445 sequencedRecognizer->inputEventType_ = InputEventType::TOUCH_SCREEN;
1446 sequencedRecognizer->touchPoints_[0] = touchEvent;
1447 sequencedRecognizer->touchPoints_[1] = touchEvent;
1448 sequencedRecognizer->childTouchTestList_.push_back(childTouchTest);
1449 sequencedRecognizer->SendTouchEventToNextRecognizer(clickRecognizerPtr, beforeDuration);
1450 EXPECT_EQ(sequencedRecognizer->touchPoints_[0].childTouchTestList, sequencedRecognizer->childTouchTestList_);
1451 }
1452
1453 /**
1454 * @tc.name: SequencedRecognizerTest031
1455 * @tc.desc: Test HandleOverdueDeadline
1456 * @tc.type: FUNC
1457 */
1458 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest031, TestSize.Level1)
1459 {
1460 /**
1461 * @tc.steps: step1. create SequencedRecognizer.
1462 */
1463 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1464 RefPtr<SequencedRecognizer> sequencedRecognizer = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1465
1466 /**
1467 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
1468 * @tc.steps: case: refereeState_ is RefereeState::PENDING.
1469 * @tc.expected: step2. result equals.
1470 */
1471 sequencedRecognizer->refereeState_ = RefereeState::PENDING;
1472 sequencedRecognizer->HandleOverdueDeadline();
1473 EXPECT_EQ(sequencedRecognizer->disposal_, GestureDisposal::REJECT);
1474 }
1475 } // namespace OHOS::Ace::NG