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 } // namespace OHOS::Ace::NG