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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SequencedRecognizer sequencedRecognizer = 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 SUCCEED();
783 sequencedRecognizer.refereeState_ = RefereeState::SUCCEED;
784 sequencedRecognizer.currentFingers_ = 0;
785 sequencedRecognizer.CleanRecognizerState();
786 SUCCEED();
787 sequencedRecognizer.refereeState_ = RefereeState::FAIL;
788 sequencedRecognizer.currentFingers_ = 0;
789 sequencedRecognizer.CleanRecognizerState();
790 SUCCEED();
791 sequencedRecognizer.refereeState_ = RefereeState::DETECTING;
792 sequencedRecognizer.currentFingers_ = 0;
793 sequencedRecognizer.CleanRecognizerState();
794 SUCCEED();
795 sequencedRecognizer.refereeState_ = RefereeState::SUCCEED_BLOCKED;
796 sequencedRecognizer.currentFingers_ = 0;
797 sequencedRecognizer.CleanRecognizerState();
798 SUCCEED();
799 sequencedRecognizer.refereeState_ = RefereeState::FAIL;
800 sequencedRecognizer.currentFingers_ = 1;
801 sequencedRecognizer.CleanRecognizerState();
802 SUCCEED();
803 sequencedRecognizer.recognizers_.clear();
804 sequencedRecognizer.CleanRecognizerState();
805 SUCCEED();
806 }
807
808 /**
809 * @tc.name: SequencedRecognizerTest014
810 * @tc.desc: Test ForceCleanRecognizer
811 * @tc.type: FUNC
812 */
813 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest014, TestSize.Level1)
814 {
815 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
816 SequencedRecognizer sequencedRecognizer = SequencedRecognizer(recognizers);
817 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
818 AxisEvent point;
819 point.action = AxisAction::NONE;
820 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
821 sequencedRecognizer.recognizers_.clear();
822 sequencedRecognizer.recognizers_.push_back(clickRecognizerPtr);
823 sequencedRecognizer.ForceCleanRecognizer();
824 SUCCEED();
825 }
826
827 /**
828 * @tc.name: SequencedRecognizerTest015
829 * @tc.desc: Test ForceCleanRecognizer
830 * @tc.type: FUNC
831 */
832 HWTEST_F(SequencedRecognizerTestNg, SequencedRecognizerTest015, TestSize.Level1)
833 {
834 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
835 SequencedRecognizer sequencedRecognizer = SequencedRecognizer(recognizers);
836 RefPtr<SequencedRecognizer> sequencedRecognizerPtr = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
837 AxisEvent point;
838 point.action = AxisAction::NONE;
839 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
840 sequencedRecognizer.recognizers_.clear();
841 sequencedRecognizer.ForceCleanRecognizer();
842 SUCCEED();
843 }
844 } // namespace OHOS::Ace::NG