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
16 #include "test/unittest/core/gestures/gestures_common_test_ng.h"
17 #include "test/mock/core/common/mock_container.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21
22 namespace OHOS::Ace::NG {
23 class GestureRefereeTestNg : public GesturesCommonTestNg {
24 public:
25 static void SetUpTestSuite();
26 static void TearDownTestSuite();
27 };
28
SetUpTestSuite()29 void GestureRefereeTestNg::SetUpTestSuite()
30 {
31 MockPipelineContext::SetUp();
32 MockContainer::SetUp();
33 }
34
TearDownTestSuite()35 void GestureRefereeTestNg::TearDownTestSuite()
36 {
37 MockPipelineContext::TearDown();
38 MockContainer::TearDown();
39 }
40
41 /**
42 * @tc.name: GestureRefereeTest001
43 * @tc.desc: Test GestureReferee Existed function
44 */
45 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest001, TestSize.Level1)
46 {
47 /**
48 * @tc.steps: step1. create GestureScope and clickRecognizer.
49 */
50 GestureScope gestureScope = GestureScope(0);
51 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
52 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
53
54 /**
55 * @tc.steps: step2. call Existed function and compare result
56 * @tc.steps: case1: input is ptr, have input
57 * @tc.steps: expected equal
58 */
59 auto result = gestureScope.Existed(clickRecognizerPtr);
60 EXPECT_EQ(result, true);
61
62 /**
63 * @tc.steps: step2. call Existed function and compare result
64 * @tc.steps: case2: input is nullptr
65 * @tc.steps: expected equal
66 */
67 result = gestureScope.Existed(nullptr);
68 EXPECT_EQ(result, false);
69
70 /**
71 * @tc.steps: step2. call Existed function and compare result
72 * @tc.steps: case3: recognizers is empty
73 * @tc.steps: expected equal
74 */
75 gestureScope.recognizers_.clear();
76 result = gestureScope.Existed(clickRecognizerPtr);
77 EXPECT_EQ(result, false);
78 }
79
80 /**
81 * @tc.name: GestureRefereeTest002
82 * @tc.desc: Test GestureReferee CheckNeedBlocked function
83 */
84 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest002, TestSize.Level1)
85 {
86 /**
87 * @tc.steps: step1. create GestureScope and clickRecognizer.
88 */
89 GestureScope gestureScope = GestureScope(0);
90 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
91 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
92
93 /**
94 * @tc.steps: step2. call Existed function and compare result
95 * @tc.steps: case1: member == input
96 * @tc.steps: expected equal
97 */
98 auto result = gestureScope.CheckNeedBlocked(clickRecognizerPtr);
99 EXPECT_EQ(result, false);
100
101 /**
102 * @tc.steps: step2. call Existed function and compare result
103 * @tc.steps: case1: member != input, refereeState is PENDING
104 * @tc.steps: expected equal
105 */
106 RefPtr<ClickRecognizer> clickRecognizerPtrNotInsert = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
107 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
108 result = gestureScope.CheckNeedBlocked(clickRecognizerPtrNotInsert);
109 EXPECT_EQ(result, true);
110
111 /**
112 * @tc.steps: step2. call Existed function and compare result
113 * @tc.steps: case3: recognizers is empty
114 * @tc.steps: expected equal
115 */
116 gestureScope.recognizers_.clear();
117 result = gestureScope.CheckNeedBlocked(clickRecognizerPtr);
118 EXPECT_EQ(result, false);
119 }
120
121 /**
122 * @tc.name: GestureRefereeCheckNeedBlockedTest001
123 * @tc.desc: Test GestureReferee CheckNeedBlocked function
124 */
125 HWTEST_F(GestureRefereeTestNg, GestureRefereeCheckNeedBlockedTest001, TestSize.Level1)
126 {
127 /**
128 * @tc.steps: step1. create GestureScope and clickRecognizer.
129 */
130 GestureScope gestureScope = GestureScope(0);
131 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
132 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
133
134 /**
135 * @tc.steps: step2. call Existed function and compare result
136 * @tc.steps: case1: member == input
137 * @tc.steps: expected equal
138 */
139 auto result = gestureScope.CheckNeedBlocked(clickRecognizerPtr);
140 EXPECT_FALSE(result);
141
142 /**
143 * @tc.steps: step2. call Existed function and compare result
144 * @tc.steps: case1: member != input, refereeState is PENDING
145 * @tc.steps: expected equal
146 */
147 RefPtr<ClickRecognizer> clickRecognizerPtrNotInsert = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
148 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
149 result = gestureScope.CheckNeedBlocked(clickRecognizerPtrNotInsert);
150 EXPECT_FALSE(result);
151
152 /**
153 * @tc.steps: step2. call Existed function and compare result
154 * @tc.steps: case3: recognizers is empty
155 * @tc.steps: expected equal
156 */
157 gestureScope.recognizers_.clear();
158 result = gestureScope.CheckNeedBlocked(clickRecognizerPtr);
159 EXPECT_FALSE(result);
160 }
161
162 /**
163 * @tc.name: GestureRefereeOnAcceptGestureTest001
164 * @tc.desc: Test GestureReferee OnAcceptGesture function
165 */
166 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest001, TestSize.Level1)
167 {
168 /**
169 * @tc.steps: step1. create GestureScope and clickRecognizer.
170 */
171 GestureScope gestureScope = GestureScope(0);
172 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
173 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
174
175 /**
176 * @tc.steps: step2. call OnAcceptGesture function and compare result
177 * @tc.steps: case1: gesture == recognizer
178 * @tc.steps: expected equal
179 */
__anon5efd2f360102(size_t info) 180 auto onActionStart = [](size_t info) { return; };
181 gestureScope.queryStateFunc_ = onActionStart;
182 gestureScope.OnAcceptGesture(clickRecognizerPtr);
183 EXPECT_EQ(gestureScope.hasGestureAccepted_, true);
184
185 /**
186 * @tc.steps: step2. call OnAcceptGesture function and compare result
187 * @tc.steps: case2: gesture != recognizer
188 * @tc.steps: expected equal
189 */
190 RefPtr<ClickRecognizer> clickRecognizerPtrNotInsert = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
191 gestureScope.OnAcceptGesture(clickRecognizerPtrNotInsert);
192 EXPECT_EQ(gestureScope.hasGestureAccepted_, true);
193
194 /**
195 * @tc.steps: step2. call OnAcceptGesture function and compare result
196 * @tc.steps: case3: recognizers is empty
197 * @tc.steps: expected equal
198 */
199 gestureScope.recognizers_.clear();
200 gestureScope.OnAcceptGesture(clickRecognizerPtr);
201 EXPECT_EQ(gestureScope.hasGestureAccepted_, true);
202
203 /**
204 * @tc.steps: step2. call OnAcceptGesture function and compare result
205 * @tc.steps: case4: recognizers have nullptr
206 * @tc.steps: expected equal
207 */
208 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), nullptr);
209 gestureScope.OnAcceptGesture(clickRecognizerPtr);
210 EXPECT_EQ(gestureScope.hasGestureAccepted_, true);
211 }
212
213 /**
214 * @tc.name: GestureRefereeTest003
215 * @tc.desc: Test GestureReferee OnAcceptGesture function
216 */
217 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest003, TestSize.Level1)
218 {
219 /**
220 * @tc.steps: step1. create GestureScope and clickRecognizer.
221 */
222 GestureScope gestureScope = GestureScope(0);
223 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
224 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
225
226 /**
227 * @tc.steps: step2. call OnAcceptGesture function and compare result
228 * @tc.steps: case1: gesture == recognizer
229 * @tc.steps: expected equal
230 */
231 gestureScope.OnAcceptGesture(clickRecognizerPtr);
232 EXPECT_EQ(gestureScope.hasGestureAccepted_, true);
233
234 /**
235 * @tc.steps: step2. call OnAcceptGesture function and compare result
236 * @tc.steps: case2: gesture != recognizer
237 * @tc.steps: expected equal
238 */
239 RefPtr<ClickRecognizer> clickRecognizerPtrNotInsert = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
240 gestureScope.OnAcceptGesture(clickRecognizerPtrNotInsert);
241 EXPECT_EQ(gestureScope.hasGestureAccepted_, true);
242
243 /**
244 * @tc.steps: step2. call OnAcceptGesture function and compare result
245 * @tc.steps: case3: recognizers is empty
246 * @tc.steps: expected equal
247 */
248 gestureScope.recognizers_.clear();
249 gestureScope.OnAcceptGesture(clickRecognizerPtr);
250 EXPECT_EQ(gestureScope.hasGestureAccepted_, true);
251
252 /**
253 * @tc.steps: step2. call OnAcceptGesture function and compare result
254 * @tc.steps: case4: recognizers have nullptr
255 * @tc.steps: expected equal
256 */
257 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), nullptr);
258 gestureScope.OnAcceptGesture(clickRecognizerPtr);
259 EXPECT_EQ(gestureScope.hasGestureAccepted_, true);
260 }
261
262 /**
263 * @tc.name: GestureRefereeTest004
264 * @tc.desc: Test GestureReferee OnBlockGesture function
265 */
266 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest004, TestSize.Level1)
267 {
268 /**
269 * @tc.steps: step1. create GestureScope and clickRecognizer.
270 */
271 GestureScope gestureScope = GestureScope(0);
272 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
273 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
274
275 /**
276 * @tc.steps: step2. call UnBlockGesture function and compare result
277 * @tc.steps: expected equal
278 */
279 auto result = gestureScope.UnBlockGesture();
280 EXPECT_EQ(result, nullptr);
281
282 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
283 result = gestureScope.UnBlockGesture();
284 EXPECT_EQ(result, clickRecognizerPtr);
285 }
286
287 /**
288 * @tc.name: GestureRefereeTest005
289 * @tc.desc: Test GestureReferee IsPending function
290 */
291 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest005, TestSize.Level1)
292 {
293 /**
294 * @tc.steps: step1. create GestureScope and clickRecognizer.
295 */
296 GestureScope gestureScope = GestureScope(0);
297 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
298 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
299
300 /**
301 * @tc.steps: step2. call IsPending function and compare result
302 * @tc.steps: expected equal
303 */
304 auto result = gestureScope.IsPending(0);
305 EXPECT_EQ(result, false);
306
307 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
308 result = gestureScope.IsPending(0);
309 EXPECT_EQ(result, true);
310 }
311
312 /**
313 * @tc.name: GestureRefereeIsPendingTest001
314 * @tc.desc: Test GestureReferee IsPending function
315 */
316 HWTEST_F(GestureRefereeTestNg, GestureRefereeIsPendingTest001, TestSize.Level1)
317 {
318 /**
319 * @tc.steps: step1. create GestureScope and clickRecognizer.
320 */
321 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
322 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
323 GestureScope gestureScope = GestureScope(0);
324 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
325 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
326 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), exclusiveRecognizerPtr);
327 gestureScope.recognizers_.push_back(nullptr);
328
329 gestureScope.AddMember(clickRecognizerPtr);
330 gestureScope.AddMember(exclusiveRecognizerPtr);
331
332 /**
333 * @tc.steps: step2. call IsPending function and compare result
334 * @tc.steps: expected equal
335 */
336 auto result = gestureScope.IsPending(0);
337 EXPECT_EQ(result, false);
338
339 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
340 result = gestureScope.IsPending(0);
341 EXPECT_EQ(result, true);
342 }
343
344 /**
345 * @tc.name: GestureRefereeTest006
346 * @tc.desc: Test GestureReferee AddGestureToScope function
347 */
348 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest006, TestSize.Level1)
349 {
350 /**
351 * @tc.steps: step1. create GestureReferee.
352 */
353 GestureReferee gestureReferee;
354
355 /**
356 * @tc.steps: step2. call AddGestureToScope function and compare result
357 * @tc.steps: case1: cannot find touchId
358 * @tc.steps: expected equal
359 */
360 TouchTestResult touchTestResult;
361 gestureReferee.AddGestureToScope(0, touchTestResult);
362 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
363
364 /**
365 * @tc.steps: step2. call AddGestureToScope function and compare result
366 * @tc.steps: case2: can find touchId, result is empty
367 * @tc.steps: expected equal
368 */
369 gestureReferee.gestureScopes_.clear();
370 gestureReferee.gestureScopes_[0] = AceType::MakeRefPtr<GestureScope>(0);
371 gestureReferee.AddGestureToScope(0, touchTestResult);
372 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
373
374 /**
375 * @tc.steps: step2. call AddGestureToScope function and compare result
376 * @tc.steps: case3: can find touchId, result have nullptr
377 * @tc.steps: expected equal
378 */
379 touchTestResult.insert(touchTestResult.end(), nullptr);
380 gestureReferee.AddGestureToScope(0, touchTestResult);
381 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
382
383 /**
384 * @tc.steps: step2. call AddGestureToScope function and compare result
385 * @tc.steps: case4: can find touchId, result have ptr
386 * @tc.steps: expected equal
387 */
388 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
389 touchTestResult.clear();
390 touchTestResult.insert(touchTestResult.end(), clickRecognizerPtr);
391 gestureReferee.AddGestureToScope(0, touchTestResult);
392 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
393 }
394
395 /**
396 * @tc.name: GestureRefereeTest007
397 * @tc.desc: Test GestureReferee CleanGestureScope function
398 */
399 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest007, TestSize.Level1)
400 {
401 /**
402 * @tc.steps: step1. create GestureReferee.
403 */
404 GestureReferee gestureReferee;
405
406 /**
407 * @tc.steps: step2. call CleanGestureScope function and compare result
408 * @tc.steps: case1: gestureScope is empty
409 * @tc.steps: expected equal
410 */
411 gestureReferee.CleanGestureScope(0);
412 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
413
414 /**
415 * @tc.steps: step2. call CleanGestureScope function and compare result
416 * @tc.steps: case2: gestureScope is not empty, scope is not PENDING
417 * @tc.steps: expected equal
418 */
419 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
420 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
421 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
422 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
423 gestureReferee.gestureScopes_[0] = gestureScope;
424 gestureReferee.CleanGestureScope(0);
425 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
426
427 /**
428 * @tc.steps: step2. call CleanGestureScope function and compare result
429 * @tc.steps: case3: gestureScope is not empty, scope is PENDING
430 * @tc.steps: expected equal
431 */
432 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
433 gestureScope->recognizers_.clear();
434 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
435 gestureReferee.gestureScopes_[0] = gestureScope;
436 gestureReferee.CleanGestureScope(0);
437 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
438 }
439
440 /**
441 * @tc.name: GestureRefereeTest008
442 * @tc.desc: Test GestureReferee AddMember function
443 */
444 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest008, TestSize.Level1)
445 {
446 /**
447 * @tc.steps: step1. create GestureScope and clickRecognizer.
448 */
449 GestureScope gestureScope = GestureScope(0);
450 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
451 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
452
453 /**
454 * @tc.steps: step2. call AddMember function and compare result
455 * @tc.steps: case1: is existed
456 * @tc.steps: expected equal
457 */
458 gestureScope.AddMember(clickRecognizerPtr);
459 EXPECT_EQ(gestureScope.recognizers_.size(), 1);
460
461 /**
462 * @tc.steps: step2. call AddMember function and compare result
463 * @tc.steps: expected equal
464 */
465 gestureScope.recognizers_.clear();
466 gestureScope.AddMember(clickRecognizerPtr);
467 EXPECT_EQ(gestureScope.recognizers_.size(), 1);
468 }
469
470 /**
471 * @tc.name: GestureRefereeTest009
472 * @tc.desc: Test GestureReferee Close function
473 */
474 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest009, TestSize.Level1)
475 {
476 /**
477 * @tc.steps: step1. create GestureScope and clickRecognizer.
478 */
479 GestureScope gestureScope = GestureScope(0);
480 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
481 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
482
483 /**
484 * @tc.steps: step2. call Close function and compare result
485 * @tc.steps: case1: have ptr
486 * @tc.steps: expected equal
487 */
488 gestureScope.Close();
489 EXPECT_EQ(gestureScope.recognizers_.size(), 1);
490
491 /**
492 * @tc.steps: step2. call OnAcceptGesture function and compare result
493 * @tc.steps: case2: recognizers_ is empty
494 * @tc.steps: expected equal
495 */
496 gestureScope.recognizers_.clear();
497 gestureScope.Close();
498 EXPECT_EQ(gestureScope.recognizers_.size(), 0);
499
500 /**
501 * @tc.steps: step2. call OnAcceptGesture function and compare result
502 * @tc.steps: case3: recognizers_ have nullptr
503 * @tc.steps: expected equal
504 */
505 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), nullptr);
506 gestureScope.Close();
507 EXPECT_EQ(gestureScope.recognizers_.size(), 1);
508 }
509
510 /**
511 * @tc.name: GestureRefereeTest010
512 * @tc.desc: Test GestureReferee Adjudicate function
513 */
514 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest010, TestSize.Level1)
515 {
516 /**
517 * @tc.steps: step1. create GestureScope and clickRecognizer.
518 */
519 GestureReferee gestureReferee;
520 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
521
522 /**
523 * @tc.steps: step2. call Adjudicate function and compare result
524 * @tc.steps: case1: disposal is ACCEPT
525 * @tc.steps: expected equal
526 */
527 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
528 gestureReferee.Adjudicate(clickRecognizerPtr, GestureDisposal::ACCEPT);
529 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
530
531 /**
532 * @tc.steps: step2. call Adjudicate function and compare result
533 * @tc.steps: case2: disposal is PENDING
534 * @tc.steps: expected equal
535 */
536 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
537 gestureReferee.Adjudicate(clickRecognizerPtr, GestureDisposal::PENDING);
538 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
539
540 /**
541 * @tc.steps: step2. call Adjudicate function and compare result
542 * @tc.steps: case3: disposal is REJECT
543 * @tc.steps: expected equal
544 */
545 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
546 gestureReferee.Adjudicate(clickRecognizerPtr, GestureDisposal::REJECT);
547 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
548
549 /**
550 * @tc.steps: step2. call Adjudicate function and compare result
551 * @tc.steps: case4: disposal is NONE
552 * @tc.steps: expected equal
553 */
554 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
555 gestureReferee.Adjudicate(clickRecognizerPtr, GestureDisposal::NONE);
556 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
557 }
558
559 /**
560 * @tc.name: GestureRefereeTest011
561 * @tc.desc: Test GestureReferee HandleAcceptDisposal function
562 */
563 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest011, TestSize.Level1)
564 {
565 /**
566 * @tc.steps: step1. create GestureScope and clickRecognizer.
567 */
568 GestureReferee gestureReferee;
569 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
570
571 /**
572 * @tc.steps: step2. call Adjudicate function and compare result
573 * @tc.steps: case1: refereeState is SUCCEED
574 * @tc.steps: expected equal
575 */
576 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
577 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr);
578 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
579
580 /**
581 * @tc.steps: step2. call Adjudicate function and compare result
582 * @tc.steps: case2: refereeState is PENDING, gestureScopes_ is empty
583 * @tc.steps: expected equal
584 */
585 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
586 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr);
587 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
588
589 /**
590 * @tc.steps: step2. call Adjudicate function and compare result
591 * @tc.steps: case3: refereeState is PENDING, gestureScopes_ is not empty
592 * @tc.steps: expected equal
593 */
594 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
595 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
596 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
597 gestureReferee.gestureScopes_[0] = gestureScope;
598 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr);
599 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
600
601 /**
602 * @tc.steps: step2. call Adjudicate function and compare result
603 * @tc.steps: case4: refereeState is PENDING, gestureScopes_ is not empty, isDelay
604 * @tc.steps: expected equal
605 */
606 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
607 gestureScope->isDelay_ = true;
608 gestureReferee.gestureScopes_[0] = gestureScope;
609 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr);
610 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
611
612 /**
613 * @tc.steps: step2. call Adjudicate function and compare result
614 * @tc.steps: case5: refereeState is PENDING, gestureScopes_ is not empty, !isDelay
615 * @tc.steps: expected equal
616 */
617 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
618 gestureScope->isDelay_ = false;
619 gestureReferee.gestureScopes_[0] = gestureScope;
620 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr);
621 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
622
623 /**
624 * @tc.steps: step2. call Adjudicate function and compare result
625 * @tc.steps: case6: refereeState is FAIL
626 * @tc.steps: expected equal
627 */
628 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
629 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr);
630 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
631 }
632
633 /**
634 * @tc.name: GestureRefereeHandleRejectDisposalTest001
635 * @tc.desc: Test GestureReferee HandleRejectDisposal function
636 */
637 HWTEST_F(GestureRefereeTestNg, GestureRefereeHandleRejectDisposalTest001, TestSize.Level1)
638 {
639 /**
640 * @tc.steps: step1. create GestureScope and clickRecognizer.
641 */
642 GestureReferee gestureReferee;
643 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
644 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
645 clickRecognizerPtr2->refereeState_ = RefereeState::PENDING;
646
647 /**
648 * @tc.steps: step2. call Adjudicate function and compare result
649 * @tc.steps: case1: refereeState is FAIL
650 * @tc.steps: expected equal
651 */
652 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
653 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
654 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
655
656 /**
657 * @tc.steps: step2. call Adjudicate function and compare result
658 * @tc.steps: case2: refereeState is PENDING, gestureScopes_ is empty
659 * @tc.steps: expected equal
660 */
661 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
662 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
663 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
664
665 /**
666 * @tc.steps: step2. call Adjudicate function and compare result
667 * @tc.steps: case3: refereeState is PENDING, gestureScopes_ is not empty
668 * @tc.steps: expected equal
669 */
670 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
671 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
672 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
673 gestureReferee.gestureScopes_[0] = gestureScope;
674 gestureScope->AddMember(clickRecognizerPtr);
675 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
676 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
677
678 /**
679 * @tc.steps: step2. call Adjudicate function and compare result
680 * @tc.steps: case4: refereeState is PENDING_BLOCKED, gestureScopes_ is not empty
681 * @tc.steps: expected equal
682 */
683 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
684 gestureScope->recognizers_.clear();
685 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
686 gestureReferee.gestureScopes_[0] = gestureScope;
687 gestureScope->AddMember(clickRecognizerPtr);
688 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
689 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
690
691 /**
692 * @tc.steps: step2. call Adjudicate function and compare result
693 * @tc.steps: case5: refereeState is SUCCEED_BLOCKED, gestureScopes_ is not empty
694 * @tc.steps: expected equal
695 */
696 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
697 gestureScope->recognizers_.clear();
698 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
699 gestureReferee.gestureScopes_[0] = gestureScope;
700 gestureScope->AddMember(clickRecognizerPtr);
701 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
702 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
703
704 /**
705 * @tc.steps: step2. call Adjudicate function and compare result
706 * @tc.steps: case6: refereeState is PENDING, gestureScopes_ is not empty, isDelay
707 * @tc.steps: expected equal
708 */
709 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
710 gestureScope->recognizers_.clear();
711 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
712 gestureScope->isDelay_ = true;
713 gestureReferee.gestureScopes_[0] = gestureScope;
714 gestureScope->AddMember(clickRecognizerPtr);
715 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
716 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
717
718 /**
719 * @tc.steps: step2. call Adjudicate function and compare result
720 * @tc.steps: case7: refereeState is PENDING, gestureScopes_ is not empty, isDelay
721 * @tc.steps: expected equal
722 */
723 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
724 gestureScope->recognizers_.clear();
725 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
726 gestureScope->isDelay_ = false;
727 gestureReferee.gestureScopes_[0] = gestureScope;
728 gestureScope->AddMember(clickRecognizerPtr);
729 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
730 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
731 }
732
733 /**
734 * @tc.name: GestureRefereeHandleRejectDisposalTest002
735 * @tc.desc: Test GestureReferee HandleRejectDisposal function
736 */
737 HWTEST_F(GestureRefereeTestNg, GestureRefereeHandleRejectDisposalTest002, TestSize.Level1)
738 {
739 /**
740 * @tc.steps: step1. create GestureScope and clickRecognizer.
741 */
742 GestureReferee gestureReferee;
743 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
744 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
745 clickRecognizerPtr2->refereeState_ = RefereeState::PENDING;
746
747 /**
748 * @tc.steps: step2. call Adjudicate function and compare result
749 * @tc.steps: case1: refereeState is FAIL
750 * @tc.steps: expected equal
751 */
752 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
753 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
754 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
755
756 /**
757 * @tc.steps: step2. call Adjudicate function and compare result
758 * @tc.steps: case2: refereeState is PENDING, gestureScopes_ is empty
759 * @tc.steps: expected equal
760 */
761 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
762 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
763 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
764
765 /**
766 * @tc.steps: step2. call Adjudicate function and compare result
767 * @tc.steps: case3: refereeState is PENDING, gestureScopes_ is not empty
768 * @tc.steps: expected equal
769 */
770 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
771 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
772 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
773 gestureReferee.gestureScopes_[0] = gestureScope;
774 gestureScope->AddMember(clickRecognizerPtr);
775 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
776 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
777
778 /**
779 * @tc.steps: step2. call Adjudicate function and compare result
780 * @tc.steps: case4: refereeState is PENDING_BLOCKED, gestureScopes_ is not empty
781 * @tc.steps: expected equal
782 */
783 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
784 gestureScope->recognizers_.clear();
785 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
786 gestureReferee.gestureScopes_[0] = gestureScope;
787 gestureScope->AddMember(clickRecognizerPtr);
788 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
789 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
790
791 /**
792 * @tc.steps: step2. call Adjudicate function and compare result
793 * @tc.steps: case5: refereeState is SUCCEED_BLOCKED, gestureScopes_ is not empty
794 * @tc.steps: expected equal
795 */
796 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
797 gestureScope->recognizers_.clear();
798 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
799 gestureReferee.gestureScopes_[0] = gestureScope;
800 gestureScope->AddMember(clickRecognizerPtr);
801 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
802 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
803
804 /**
805 * @tc.steps: step2. call Adjudicate function and compare result
806 * @tc.steps: case6: refereeState is PENDING, gestureScopes_ is not empty, isDelay
807 * @tc.steps: expected equal
808 */
809 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
810 gestureScope->recognizers_.clear();
811 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
812 gestureScope->isDelay_ = true;
813 gestureReferee.gestureScopes_[0] = gestureScope;
814 gestureScope->AddMember(clickRecognizerPtr);
815 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
816 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
817
818 /**
819 * @tc.steps: step2. call Adjudicate function and compare result
820 * @tc.steps: case7: refereeState is PENDING, gestureScopes_ is not empty, isDelay
821 * @tc.steps: expected equal
822 */
823 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
824 gestureScope->recognizers_.clear();
825 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
826 gestureScope->isDelay_ = false;
827 gestureReferee.gestureScopes_[0] = gestureScope;
828 gestureScope->AddMember(clickRecognizerPtr);
829 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
830 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
831 }
832
833 /**
834 * @tc.name: GestureRefereeHandlePendingDisposalTest012
835 * @tc.desc: Test GestureReferee HandlePendingDisposal function
836 */
837 HWTEST_F(GestureRefereeTestNg, GestureRefereeHandlePendingDisposalTest012, TestSize.Level1)
838 {
839 /**
840 * @tc.steps: step1. create GestureScope and clickRecognizer.
841 */
842 GestureReferee gestureReferee;
843 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
844 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
845
846 /**
847 * @tc.steps: step2. call Adjudicate function and compare result
848 * @tc.steps: case1: refereeState is PENDING
849 * @tc.steps: expected equal
850 */
851 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
852 gestureReferee.HandlePendingDisposal(clickRecognizerPtr);
853 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
854
855 /**
856 * @tc.steps: step2. call Adjudicate function and compare result
857 * @tc.steps: case2: refereeState is SUCCEED, gestureScopes_ is empty
858 * @tc.steps: expected equal
859 */
860 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
861 gestureReferee.HandlePendingDisposal(clickRecognizerPtr);
862 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
863
864 /**
865 * @tc.steps: step2. call Adjudicate function and compare result
866 * @tc.steps: case3: refereeState is SUCCEED, gestureScopes_ is not empty
867 * @tc.steps: expected equal
868 */
869 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
870 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
871 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
872 gestureReferee.gestureScopes_[0] = gestureScope;
873 gestureReferee.HandlePendingDisposal(clickRecognizerPtr2);
874 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
875 }
876
877 /**
878 * @tc.name: GestureRefereeTestHandleAcceptDisposal005
879 * @tc.desc: Test GestureReferee HandleAcceptDisposal function
880 */
881 HWTEST_F(GestureRefereeTestNg, GestureRefereeTestHandleAcceptDisposal005, TestSize.Level1)
882 {
883 /**
884 * @tc.steps: step1. create GestureScope and clickRecognizer.
885 */
886 GestureReferee gestureReferee;
887 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
888 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
889
890 /**
891 * @tc.steps: step2. call Adjudicate function and compare result
892 * @tc.steps: case1: refereeState is PENDING
893 * @tc.steps: expected equal
894 */
895 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
896 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
897 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
898
899 /**
900 * @tc.steps: step2. call Adjudicate function and compare result
901 * @tc.steps: case2: refereeState is SUCCEED, gestureScopes_ is empty
902 * @tc.steps: expected equal
903 */
904 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
905 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
906 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
907
908 /**
909 * @tc.steps: step2. call Adjudicate function and compare result
910 * @tc.steps: case3: refereeState is SUCCEED, gestureScopes_ is not empty
911 * @tc.steps: expected equal
912 */
913 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
914 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
915 gestureScope->recognizers_.clear();
916 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
917 gestureScope->AddMember(clickRecognizerPtr);
918 gestureReferee.gestureScopes_[0] = gestureScope;
919 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
920 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
921 }
922
923 /**
924 * @tc.name: GestureRefereeHandleAcceptDisposalTest006
925 * @tc.desc: Test GestureReferee HandleAcceptDisposal function
926 */
927 HWTEST_F(GestureRefereeTestNg, GestureRefereeHandleAcceptDisposalTest006, TestSize.Level1)
928 {
929 /**
930 * @tc.steps: step1. create GestureScope and clickRecognizer.
931 */
932 GestureReferee gestureReferee;
933 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
934 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
935
936 /**
937 * @tc.steps: step2. call Adjudicate function and compare result
938 * @tc.steps: case1: refereeState is PENDING
939 * @tc.steps: expected equal
940 */
941 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
942 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr);
943 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
944
945 /**
946 * @tc.steps: step2. call Adjudicate function and compare result
947 * @tc.steps: case2: refereeState is SUCCEED, gestureScopes_ is empty
948 * @tc.steps: expected equal
949 */
950 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
951 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr);
952 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
953
954 /**
955 * @tc.steps: step2. call Adjudicate function and compare result
956 * @tc.steps: case3: refereeState is SUCCEED, gestureScopes_ is not empty
957 * @tc.steps: expected equal
958 */
959 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
960 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
961 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
962 gestureReferee.gestureScopes_[0] = gestureScope;
963 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
964 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
965 }
966
967 /**
968 * @tc.name: GestureRefereeHandleAcceptDisposalTest001
969 * @tc.desc: Test GestureReferee HandleAcceptDisposal function
970 */
971 HWTEST_F(GestureRefereeTestNg, GestureRefereeHandleAcceptDisposalTest001, TestSize.Level1)
972 {
973 /**
974 * @tc.steps: step1. create GestureScope and clickRecognizer.
975 */
976 GestureReferee gestureReferee;
977 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
978 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
979
980 /**
981 * @tc.steps: step2. call Adjudicate function and compare result
982 * @tc.steps: case1: refereeState is SUCCEED
983 * @tc.steps: expected equal
984 */
985 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
986 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
987 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
988
989 /**
990 * @tc.steps: step2. call Adjudicate function and compare result
991 * @tc.steps: case2: refereeState is PENDING, gestureScopes_ is empty
992 * @tc.steps: expected equal
993 */
994 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
995 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
996 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
997
998 /**
999 * @tc.steps: step2. call Adjudicate function and compare result
1000 * @tc.steps: case3: refereeState is PENDING, gestureScopes_ is not empty
1001 * @tc.steps: expected equal
1002 */
1003 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1004 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1005 gestureScope->recognizers_.clear();
1006 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1007 gestureScope->AddMember(clickRecognizerPtr);
1008 gestureReferee.gestureScopes_[0] = gestureScope;
1009 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
1010 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1011
1012 /**
1013 * @tc.steps: step2. call Adjudicate function and compare result
1014 * @tc.steps: case4: refereeState is PENDING, gestureScopes_ is not empty, isDelay
1015 * @tc.steps: expected equal
1016 */
1017 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1018 gestureScope->isDelay_ = true;
1019 gestureScope->recognizers_.clear();
1020 gestureScope->AddMember(clickRecognizerPtr);
1021 gestureReferee.gestureScopes_[0] = gestureScope;
1022 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
1023 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1024
1025 /**
1026 * @tc.steps: step2. call Adjudicate function and compare result
1027 * @tc.steps: case5: refereeState is PENDING, gestureScopes_ is not empty, !isDelay
1028 * @tc.steps: expected equal
1029 */
1030 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1031 gestureScope->isDelay_ = false;
1032 gestureReferee.gestureScopes_[0] = gestureScope;
1033 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
1034 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1035
1036 /**
1037 * @tc.steps: step2. call Adjudicate function and compare result
1038 * @tc.steps: case6: refereeState is FAIL
1039 * @tc.steps: expected equal
1040 */
1041 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
1042 gestureReferee.HandleAcceptDisposal(clickRecognizerPtr2);
1043 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1044 }
1045
1046 /**
1047 * @tc.name: GestureRefereeTestHandlePendingDisposal001
1048 * @tc.desc: Test GestureReferee HandlePendingDisposal function
1049 */
1050 HWTEST_F(GestureRefereeTestNg, GestureRefereeTestHandlePendingDisposal001, TestSize.Level1)
1051 {
1052 /**
1053 * @tc.steps: step1. create GestureScope and clickRecognizer.
1054 */
1055 GestureReferee gestureReferee;
1056 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1057 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1058
1059 /**
1060 * @tc.steps: step2. call Adjudicate function and compare result
1061 * @tc.steps: case1: refereeState is PENDING
1062 * @tc.steps: expected equal
1063 */
1064 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1065 gestureReferee.HandlePendingDisposal(clickRecognizerPtr2);
1066 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
1067
1068 /**
1069 * @tc.steps: step2. call Adjudicate function and compare result
1070 * @tc.steps: case2: refereeState is SUCCEED, gestureScopes_ is empty
1071 * @tc.steps: expected equal
1072 */
1073 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1074 gestureReferee.HandlePendingDisposal(clickRecognizerPtr2);
1075 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
1076
1077 /**
1078 * @tc.steps: step2. call Adjudicate function and compare result
1079 * @tc.steps: case3: refereeState is SUCCEED, gestureScopes_ is not empty
1080 * @tc.steps: expected equal
1081 */
1082 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1083 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1084 gestureScope->recognizers_.clear();
1085 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1086 gestureScope->AddMember(clickRecognizerPtr);
1087 gestureReferee.gestureScopes_[0] = gestureScope;
1088 gestureReferee.HandlePendingDisposal(clickRecognizerPtr2);
1089 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1090 }
1091
1092 /**
1093 * @tc.name: GestureRefereeTest012
1094 * @tc.desc: Test GestureReferee HandlePendingDisposal function
1095 */
1096 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest012, TestSize.Level1)
1097 {
1098 /**
1099 * @tc.steps: step1. create GestureScope and clickRecognizer.
1100 */
1101 GestureReferee gestureReferee;
1102 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1103
1104 /**
1105 * @tc.steps: step2. call Adjudicate function and compare result
1106 * @tc.steps: case1: refereeState is PENDING
1107 * @tc.steps: expected equal
1108 */
1109 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1110 gestureReferee.HandlePendingDisposal(clickRecognizerPtr);
1111 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
1112
1113 /**
1114 * @tc.steps: step2. call Adjudicate function and compare result
1115 * @tc.steps: case2: refereeState is SUCCEED, gestureScopes_ is empty
1116 * @tc.steps: expected equal
1117 */
1118 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1119 gestureReferee.HandlePendingDisposal(clickRecognizerPtr);
1120 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
1121
1122 /**
1123 * @tc.steps: step2. call Adjudicate function and compare result
1124 * @tc.steps: case3: refereeState is SUCCEED, gestureScopes_ is not empty
1125 * @tc.steps: expected equal
1126 */
1127 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1128 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1129 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1130 gestureReferee.gestureScopes_[0] = gestureScope;
1131 gestureReferee.HandlePendingDisposal(clickRecognizerPtr);
1132 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1133 }
1134
1135 /**
1136 * @tc.name: GestureRefereeTest013
1137 * @tc.desc: Test GestureReferee HandleRejectDisposal function
1138 */
1139 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest013, TestSize.Level1)
1140 {
1141 /**
1142 * @tc.steps: step1. create GestureScope and clickRecognizer.
1143 */
1144 GestureReferee gestureReferee;
1145 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1146 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1147
1148 /**
1149 * @tc.steps: step2. call Adjudicate function and compare result
1150 * @tc.steps: case1: refereeState is FAIL
1151 * @tc.steps: expected equal
1152 */
1153 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
1154 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
1155 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
1156
1157 /**
1158 * @tc.steps: step2. call Adjudicate function and compare result
1159 * @tc.steps: case2: refereeState is PENDING, gestureScopes_ is empty
1160 * @tc.steps: expected equal
1161 */
1162 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1163 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
1164 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
1165
1166 /**
1167 * @tc.steps: step2. call Adjudicate function and compare result
1168 * @tc.steps: case3: refereeState is PENDING, gestureScopes_ is not empty
1169 * @tc.steps: expected equal
1170 */
1171 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1172 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1173 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1174 gestureReferee.gestureScopes_[0] = gestureScope;
1175 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
1176 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1177
1178 /**
1179 * @tc.steps: step2. call Adjudicate function and compare result
1180 * @tc.steps: case4: refereeState is PENDING_BLOCKED, gestureScopes_ is not empty
1181 * @tc.steps: expected equal
1182 */
1183 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1184 gestureScope->recognizers_.clear();
1185 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1186 gestureReferee.gestureScopes_[0] = gestureScope;
1187 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
1188 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1189
1190 /**
1191 * @tc.steps: step2. call Adjudicate function and compare result
1192 * @tc.steps: case5: refereeState is SUCCEED_BLOCKED, gestureScopes_ is not empty
1193 * @tc.steps: expected equal
1194 */
1195 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1196 gestureScope->recognizers_.clear();
1197 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1198 gestureReferee.gestureScopes_[0] = gestureScope;
1199 gestureReferee.HandleRejectDisposal(clickRecognizerPtr2);
1200 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1201
1202 /**
1203 * @tc.steps: step2. call Adjudicate function and compare result
1204 * @tc.steps: case6: refereeState is PENDING, gestureScopes_ is not empty, isDelay
1205 * @tc.steps: expected equal
1206 */
1207 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1208 gestureScope->recognizers_.clear();
1209 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1210 gestureScope->isDelay_ = true;
1211 gestureReferee.gestureScopes_[0] = gestureScope;
1212 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
1213 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1214
1215 /**
1216 * @tc.steps: step2. call Adjudicate function and compare result
1217 * @tc.steps: case7: refereeState is PENDING, gestureScopes_ is not empty, isDelay
1218 * @tc.steps: expected equal
1219 */
1220 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1221 gestureScope->recognizers_.clear();
1222 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1223 gestureScope->isDelay_ = false;
1224 gestureReferee.gestureScopes_[0] = gestureScope;
1225 gestureReferee.HandleRejectDisposal(clickRecognizerPtr);
1226 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1227 }
1228
1229 /**
1230 * @tc.name: GestureRefereeTest014
1231 * @tc.desc: Test GestureReferee HasGestureAccepted function
1232 */
1233 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest014, TestSize.Level1)
1234 {
1235 /**
1236 * @tc.steps: step1. create GestureScope and clickRecognizer.
1237 */
1238 GestureReferee gestureReferee;
1239 bool result = false;
1240
1241 /**
1242 * @tc.steps: step2. call Adjudicate function and compare result
1243 * @tc.steps: case1: gestureScopes_ is not empty
1244 * @tc.steps: expected equal
1245 */
1246 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1247 gestureReferee.gestureScopes_[0] = gestureScope;
1248 result = gestureReferee.HasGestureAccepted(0);
1249 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1250 EXPECT_EQ(result, false);
1251
1252 /**
1253 * @tc.steps: step2. call Adjudicate function and compare result
1254 * @tc.steps: case1: gestureScopes_ is empty
1255 * @tc.steps: expected equal
1256 */
1257 gestureReferee.gestureScopes_.clear();
1258 result = gestureReferee.HasGestureAccepted(0);
1259 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
1260 EXPECT_EQ(result, false);
1261 }
1262
1263 /**
1264 * @tc.name: GestureRefereeTest015
1265 * @tc.desc: Test GestureReferee QueryAllDone function
1266 */
1267 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest015, TestSize.Level1)
1268 {
1269 /**
1270 * @tc.steps: step1. create GestureScope and clickRecognizer.
1271 */
1272 GestureScope gestureScope = GestureScope(0);
1273 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1274 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
1275
1276 /**
1277 * @tc.steps: step2. call QueryAllDone function
1278 * @tc.steps: expected equal
1279 */
1280 gestureScope.AddMember(clickRecognizerPtr);
1281 EXPECT_EQ(gestureScope.recognizers_.size(), 1);
1282 gestureScope.QueryAllDone(0);
1283
1284 /**
1285 * @tc.steps: step2. call QueryAllDone function
1286 * @tc.steps: expected equal
1287 */
1288 gestureScope.recognizers_.clear();
1289 gestureScope.AddMember(clickRecognizerPtr);
1290 EXPECT_EQ(gestureScope.recognizers_.size(), 1);
1291 gestureScope.QueryAllDone(1);
1292 }
1293
1294 /**
1295 * @tc.name: GestureRefereeTest016
1296 * @tc.desc: Test GestureReferee QueryAllDone function
1297 */
1298 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest016, TestSize.Level1)
1299 {
1300 /**
1301 * @tc.steps: step1. create GestureScope and clickRecognizer.
1302 */
1303 GestureReferee gestureReferee;
1304 bool result = false;
1305
1306 /**
1307 * @tc.steps: step2. call QueryAllDone function
1308 * @tc.steps: expected equal
1309 */
1310 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1311 gestureReferee.gestureScopes_[0] = gestureScope;
1312 result = gestureReferee.QueryAllDone(0);
1313 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 1);
1314 EXPECT_EQ(result, true);
1315 }
1316
1317 /**
1318 * @tc.name: GestureRefereeQueryAllDoneTest001
1319 * @tc.desc: Test GestureReferee QueryAllDone function
1320 */
1321 HWTEST_F(GestureRefereeTestNg, GestureRefereeQueryAllDoneTest001, TestSize.Level1)
1322 {
1323 /**
1324 * @tc.steps: step1. create GestureScope and clickRecognizer.
1325 */
1326 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1327 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1328
1329 GestureScope gestureScope = GestureScope(0);
1330 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1331 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1332 clickRecognizerPtr2->refereeState_ = RefereeState::PENDING_BLOCKED;
1333
1334 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
1335 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), exclusiveRecognizerPtr);
1336 gestureScope.recognizers_.push_back(nullptr);
1337
1338 /**
1339 * @tc.steps: step2. call QueryAllDone function
1340 * @tc.steps: expected equal
1341 */
1342 gestureScope.AddMember(exclusiveRecognizerPtr);
1343 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1344 gestureScope.QueryAllDone(0);
1345
1346 /**
1347 * @tc.steps: step2. call QueryAllDone function
1348 * @tc.steps: expected equal
1349 */
1350 gestureScope.recognizers_.clear();
1351 gestureScope.AddMember(clickRecognizerPtr);
1352 EXPECT_EQ(gestureScope.recognizers_.size(), 1);
1353 gestureScope.QueryAllDone(1);
1354 }
1355
1356 /**
1357 * @tc.name: GestureRefereeQueryAllDoneTest005
1358 * @tc.desc: Test GestureReferee QueryAllDone function
1359 */
1360 HWTEST_F(GestureRefereeTestNg, GestureRefereeQueryAllDoneTest005, TestSize.Level1)
1361 {
1362 /**
1363 * @tc.steps: step1. create GestureScope and clickRecognizer.
1364 */
1365 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1366 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1367
1368 GestureScope gestureScope = GestureScope(0);
1369 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1370 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1371 clickRecognizerPtr2->refereeState_ = RefereeState::SUCCEED;
1372 recognizers.insert(recognizers.end(), clickRecognizerPtr2);
1373
1374 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
1375 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), exclusiveRecognizerPtr);
1376 gestureScope.recognizers_.push_back(nullptr);
1377
1378 /**
1379 * @tc.steps: step2. call QueryAllDone function
1380 * @tc.steps: expected equal
1381 */
1382 gestureScope.AddMember(clickRecognizerPtr);
1383 gestureScope.AddMember(exclusiveRecognizerPtr);
1384 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1385 gestureScope.QueryAllDone(0);
1386
1387 /**
1388 * @tc.steps: step2. call QueryAllDone function
1389 * @tc.steps: expected equal
1390 */
1391 gestureScope.AddMember(clickRecognizerPtr);
1392 gestureScope.AddMember(exclusiveRecognizerPtr);
1393 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1394 gestureScope.QueryAllDone(1);
1395 }
1396
1397 /**
1398 * @tc.name: GestureRefereeQueryAllDoneTest006
1399 * @tc.desc: Test GestureReferee QueryAllDone function
1400 */
1401 HWTEST_F(GestureRefereeTestNg, GestureRefereeQueryAllDoneTest006, TestSize.Level1)
1402 {
1403 /**
1404 * @tc.steps: step1. create GestureScope and clickRecognizer.
1405 */
1406 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1407 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1408
1409 GestureScope gestureScope = GestureScope(0);
1410 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1411 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1412 clickRecognizerPtr2->refereeState_ = RefereeState::SUCCEED;
1413 recognizers.insert(recognizers.end(), clickRecognizerPtr2);
1414 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
1415 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), exclusiveRecognizerPtr);
1416 gestureScope.recognizers_.push_back(nullptr);
1417
1418 /**
1419 * @tc.steps: step2. call QueryAllDone function
1420 * @tc.steps: expected equal
1421 */
1422 gestureScope.AddMember(clickRecognizerPtr);
1423 gestureScope.AddMember(exclusiveRecognizerPtr);
1424 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1425 gestureScope.QueryAllDone(0);
1426
1427 /**
1428 * @tc.steps: step2. call QueryAllDone function
1429 * @tc.steps: expected equal
1430 */
1431 gestureScope.AddMember(clickRecognizerPtr);
1432 gestureScope.AddMember(exclusiveRecognizerPtr);
1433 gestureScope.AddMember(clickRecognizerPtr);
1434 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1435 gestureScope.QueryAllDone(1);
1436 }
1437
1438 /**
1439 * @tc.name: GestureRefereeQueryAllDoneTest002
1440 * @tc.desc: Test GestureReferee QueryAllDone function
1441 */
1442 HWTEST_F(GestureRefereeTestNg, GestureRefereeQueryAllDoneTest002, TestSize.Level1)
1443 {
1444 /**
1445 * @tc.steps: step1. create GestureScope and clickRecognizer.
1446 */
1447 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1448 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1449
1450 GestureScope gestureScope = GestureScope(0);
1451 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1452
1453 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
1454 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), exclusiveRecognizerPtr);
1455 gestureScope.recognizers_.push_back(nullptr);
1456
1457 /**
1458 * @tc.steps: step2. call QueryAllDone function
1459 * @tc.steps: expected equal
1460 */
1461 gestureScope.AddMember(exclusiveRecognizerPtr);
1462 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1463 gestureScope.QueryAllDone(0);
1464
1465 /**
1466 * @tc.steps: step2. call QueryAllDone function
1467 * @tc.steps: expected equal
1468 */
1469 gestureScope.AddMember(clickRecognizerPtr);
1470 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1471 gestureScope.QueryAllDone(1);
1472 }
1473
1474 /**
1475 * @tc.name: GestureRefereeQueryAllDoneTest003
1476 * @tc.desc: Test GestureReferee QueryAllDone function
1477 */
1478 HWTEST_F(GestureRefereeTestNg, GestureRefereeQueryAllDoneTest003, TestSize.Level1)
1479 {
1480 /**
1481 * @tc.steps: step1. create GestureScope and clickRecognizer.
1482 */
1483 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
1484 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1485
1486 GestureScope gestureScope = GestureScope(0);
1487 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1488
1489 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), clickRecognizerPtr);
1490 gestureScope.recognizers_.insert(gestureScope.recognizers_.end(), exclusiveRecognizerPtr);
1491 gestureScope.recognizers_.push_back(nullptr);
1492
1493 /**
1494 * @tc.steps: step2. call QueryAllDone function
1495 * @tc.steps: expected equal
1496 */
1497 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
1498 gestureScope.AddMember(clickRecognizerPtr);
1499 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1500 gestureScope.QueryAllDone(0);
1501
1502 /**
1503 * @tc.steps: step2. call QueryAllDone function
1504 * @tc.steps: expected equal
1505 */
1506 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1507 gestureScope.AddMember(clickRecognizerPtr);
1508 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1509 gestureScope.QueryAllDone(0);
1510
1511 /**
1512 * @tc.steps: step2. call QueryAllDone function
1513 * @tc.steps: expected equal
1514 */
1515 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
1516 gestureScope.AddMember(clickRecognizerPtr);
1517 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1518 gestureScope.QueryAllDone(0);
1519
1520 /**
1521 * @tc.steps: step2. call QueryAllDone function
1522 * @tc.steps: expected equal
1523 */
1524 clickRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
1525 gestureScope.AddMember(clickRecognizerPtr);
1526 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1527 gestureScope.QueryAllDone(0);
1528
1529 /**
1530 * @tc.steps: step2. call QueryAllDone function
1531 * @tc.steps: expected equal
1532 */
1533 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1534 gestureScope.AddMember(clickRecognizerPtr);
1535 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1536 gestureScope.QueryAllDone(0);
1537
1538 /**
1539 * @tc.steps: step2. call QueryAllDone function
1540 * @tc.steps: expected equal
1541 */
1542 clickRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1543 gestureScope.AddMember(clickRecognizerPtr);
1544 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1545 gestureScope.QueryAllDone(0);
1546
1547 /**
1548 * @tc.steps: step2. call QueryAllDone function
1549 * @tc.steps: expected equal
1550 */
1551 clickRecognizerPtr->refereeState_ = RefereeState::READY;
1552 gestureScope.AddMember(clickRecognizerPtr);
1553 EXPECT_EQ(gestureScope.recognizers_.size(), 3);
1554 gestureScope.QueryAllDone(0);
1555 }
1556
1557 /**
1558 * @tc.name: GestureRefereeTest017
1559 * @tc.desc: Test GestureReferee CleanAll function
1560 */
1561 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest017, TestSize.Level1)
1562 {
1563 /**
1564 * @tc.steps: step1. create GestureScope and clickRecognizer.
1565 */
1566 GestureReferee gestureReferee;
1567
1568 /**
1569 * @tc.steps: step2. call CleanAll() function
1570 * @tc.steps: expected equal
1571 */
1572 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1573 gestureReferee.gestureScopes_[0] = gestureScope;
1574 gestureReferee.CleanAll();
1575 EXPECT_EQ(gestureReferee.gestureScopes_.size(), 0);
1576 }
1577
1578 /**
1579 * @tc.name: GestureRefereeTest018
1580 * @tc.desc: Test GestureReferee CheckSourceTypeChange function
1581 */
1582 HWTEST_F(GestureRefereeTestNg, GestureRefereeTest018, TestSize.Level1)
1583 {
1584 /**
1585 * @tc.steps: step1. create GestureScope and clickRecognizer.
1586 */
1587 GestureReferee gestureReferee;
1588 bool result = false;
1589
1590 /**
1591 * @tc.steps: step2. call CheckSourceTypeChange function
1592 * @tc.steps: expected equal
1593 */
1594 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1595 gestureReferee.gestureScopes_[0] = gestureScope;
1596 result = gestureReferee.CheckSourceTypeChange(SourceType::TOUCH, false);
1597 EXPECT_EQ(result, true);
1598 result = gestureReferee.CheckSourceTypeChange(SourceType::TOUCH, true);
1599 EXPECT_EQ(result, true);
1600 gestureReferee.lastSourceType_ = SourceType::TOUCH;
1601 result = gestureReferee.CheckSourceTypeChange(SourceType::TOUCH, false);
1602 EXPECT_EQ(result, true);
1603 result = gestureReferee.CheckSourceTypeChange(SourceType::TOUCH, true);
1604 EXPECT_EQ(result, true);
1605 }
1606
1607 /**
1608 * @tc.name: GestureRefereeOnAcceptGestureTest019
1609 * @tc.desc: Test GestureReferee OnAcceptGesture function
1610 */
1611 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest019, TestSize.Level1)
1612 {
1613 /**
1614 * @tc.steps: step2. call CheckSourceTypeChange function
1615 * @tc.steps: expected equal
1616 */
1617 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1618 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1619 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1620 gestureScope->recognizers_.push_back(nullptr);
1621 EXPECT_EQ(gestureScope->CheckRecognizerState(), false);
1622 }
1623
1624 /**
1625 * @tc.name: GestureRefereeOnAcceptGestureTest020
1626 * @tc.desc: Test GestureReferee OnAcceptGesture function
1627 */
1628 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest020, TestSize.Level1)
1629 {
1630 /**
1631 * @tc.steps: step2. call CheckSourceTypeChange function
1632 * @tc.steps: expected equal
1633 */
1634 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1635 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1636 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
1637 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1638 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1639 gestureScope->recognizers_.push_back(nullptr);
1640 EXPECT_EQ(gestureScope->IsReady(), false);
1641 }
1642
1643 /**
1644 * @tc.name: GestureRefereeOnAcceptGestureTest021
1645 * @tc.desc: Test GestureReferee OnAcceptGesture function
1646 */
1647 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest021, TestSize.Level1)
1648 {
1649 /**
1650 * @tc.steps: step2. call CheckSourceTypeChange function
1651 * @tc.steps: expected equal
1652 */
1653 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1654 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1655 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1656 gestureScope->recognizers_.emplace_back(clickRecognizerPtr);
1657 EXPECT_EQ(gestureScope->HasFailRecognizer(), false);
1658 }
1659
1660 /**
1661 * @tc.name: GestureRefereeOnAcceptGestureTest022
1662 * @tc.desc: Test GestureReferee OnAcceptGesture function
1663 */
1664 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest022, TestSize.Level1)
1665 {
1666 /**
1667 * @tc.steps: step2. call CheckSourceTypeChange function
1668 * @tc.steps: expected equal
1669 */
1670 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1671 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1672 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
1673 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1674 gestureScope->recognizers_.push_back(nullptr);
1675 EXPECT_EQ(gestureScope->HasFailRecognizer(), true);
1676 }
1677
1678 /**
1679 * @tc.name: GestureRefereeOnAcceptGestureTest023
1680 * @tc.desc: Test GestureReferee OnAcceptGesture function
1681 */
1682 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest023, TestSize.Level1)
1683 {
1684 /**
1685 * @tc.steps: step2. call CheckSourceTypeChange function
1686 * @tc.steps: expected equal
1687 */
1688 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1689 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1690 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1691 gestureRecognizer->refereeState_ = RefereeState::DETECTING;
1692 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1693 gestureScope->recognizers_.push_back(nullptr);
1694 EXPECT_EQ(gestureScope->IsReady(), false);
1695 }
1696
1697 /**
1698 * @tc.name: GestureRefereeOnAcceptGestureTest024
1699 * @tc.desc: Test GestureReferee OnAcceptGesture function
1700 */
1701 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest024, TestSize.Level1)
1702 {
1703 /**
1704 * @tc.steps: step2. call CheckSourceTypeChange function
1705 * @tc.steps: expected equal
1706 */
1707 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1708 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1709 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1710 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1711 RefPtr<ClickRecognizer> clickRecognizerPtrOther = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1712 clickRecognizerPtrOther = nullptr;
1713 gestureScope->recognizers_.push_back(clickRecognizerPtrOther);
1714 gestureScope->ForceCleanGestureScope();
1715 SUCCEED();
1716 }
1717
1718 /**
1719 * @tc.name: GestureRefereeOnAcceptGestureTest025
1720 * @tc.desc: Test GestureReferee OnAcceptGesture function
1721 */
1722 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest025, TestSize.Level1)
1723 {
1724 /**
1725 * @tc.steps: step2. call CheckSourceTypeChange function
1726 * @tc.steps: expected equal
1727 */
1728 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1729 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1730 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1731 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1732 RefPtr<ClickRecognizer> clickRecognizerPtrOther = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1733 clickRecognizerPtrOther = nullptr;
1734 gestureScope->recognizers_.push_back(clickRecognizerPtrOther);
1735 gestureScope->ForceCleanGestureScopeState();
1736 SUCCEED();
1737 }
1738
1739 /**
1740 * @tc.name: GestureRefereeOnAcceptGestureTest026
1741 * @tc.desc: Test GestureReferee OnAcceptGesture function
1742 */
1743 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest026, TestSize.Level1)
1744 {
1745 /**
1746 * @tc.steps: step2. call CheckSourceTypeChange function
1747 * @tc.steps: expected equal
1748 */
1749 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1750 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1751 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1752 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1753 RefPtr<ClickRecognizer> clickRecognizerPtrOther = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1754 clickRecognizerPtrOther = nullptr;
1755 gestureScope->recognizers_.push_back(clickRecognizerPtrOther);
1756 gestureScope->CleanGestureScopeState();
1757 SUCCEED();
1758 }
1759
1760 /**
1761 * @tc.name: GestureRefereeOnAcceptGestureTest027
1762 * @tc.desc: Test GestureReferee OnAcceptGesture function
1763 */
1764 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest027, TestSize.Level1)
1765 {
1766 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1767 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1768 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1769 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1770 auto gesture = AceType::MakeRefPtr<NG::GestureReferee>();
1771 size_t id = 3;
1772 gesture->gestureScopes_.try_emplace(id, gestureScope);
1773 gesture->QueryAllDone();
1774 SUCCEED();
1775 }
1776
1777 /**
1778 * @tc.name: GestureRefereeOnAcceptGestureTest028
1779 * @tc.desc: Test GestureReferee OnAcceptGesture function
1780 */
1781 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest028, TestSize.Level1)
1782 {
1783 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1784 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1785 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1786 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1787 auto gesture = AceType::MakeRefPtr<NG::GestureReferee>();
1788 gesture->lastIsAxis_ = true;
1789 SourceType type = SourceType::TOUCH;
1790 bool isAxis = true;
1791 gesture->CheckEventTypeChange(type, isAxis);
1792 SUCCEED();
1793 }
1794
1795 /**
1796 * @tc.name: GestureRefereeOnAcceptGestureTest029
1797 * @tc.desc: Test GestureReferee OnAcceptGesture function
1798 */
1799 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest029, TestSize.Level1)
1800 {
1801 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1802 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1803 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1804 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1805 auto gesture = AceType::MakeRefPtr<NG::GestureReferee>();
1806 gesture->lastIsAxis_ = true;
1807 gesture->CleanRedundanceScope();
1808 SUCCEED();
1809 }
1810
1811 /**
1812 * @tc.name: GestureRefereeOnAcceptGestureTest030
1813 * @tc.desc: Test GestureReferee OnAcceptGesture function
1814 */
1815 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest030, TestSize.Level1)
1816 {
1817 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1818 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1819 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1820 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1821 auto gesture = AceType::MakeRefPtr<NG::GestureReferee>();
1822 gesture->lastIsAxis_ = true;
1823 gesture->IsReady();
1824 SUCCEED();
1825 }
1826
1827 /**
1828 * @tc.name: GestureRefereeOnAcceptGestureTest031
1829 * @tc.desc: Test GestureReferee OnAcceptGesture function
1830 */
1831 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest031, TestSize.Level1)
1832 {
1833 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1834 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1835 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1836 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1837 auto gesture = AceType::MakeRefPtr<NG::GestureReferee>();
1838 size_t id = 3;
1839 gesture->gestureScopes_.try_emplace(id, gestureScope);
1840 gesture->CleanGestureRefereeState(id);
1841 SUCCEED();
1842 id = 5;
1843 gesture->CleanGestureRefereeState(id);
1844 SUCCEED();
1845 }
1846
1847 /**
1848 * @tc.name: GestureRefereeOnAcceptGestureTest032
1849 * @tc.desc: Test GestureReferee OnAcceptGesture function
1850 */
1851 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest032, TestSize.Level1)
1852 {
1853 auto container = Container::Current();
1854 auto pipelineContext = container->GetPipelineContext();
1855 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1856 PanDirection panDirection;
1857 panDirection.type = PanDirection::VERTICAL;
1858 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>(1, panDirection, 0);
1859 std::vector<RefPtr<NGGestureRecognizer>> recognizers { panRecognizer };
1860 auto test = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1861 auto gesture = AceType::MakeRefPtr<NG::GestureReferee>();
1862 auto Ngg = AceType::DynamicCast<NG::NGGestureRecognizer>(test);
1863 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1864 gestureScope->recognizers_.emplace_back(Ngg);
1865 gestureScope->recognizers_.emplace_back(nullptr);
1866 gestureScope->CheckRecognizerState();
1867 }
1868
1869 /**
1870 * @tc.name: GestureRefereeOnAcceptGestureTest033
1871 * @tc.desc: Test GestureReferee OnAcceptGesture function
1872 */
1873 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest033, TestSize.Level1)
1874 {
1875 /**
1876 * @tc.steps: step2. call CheckSourceTypeChange function
1877 * @tc.steps: expected equal
1878 */
1879 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1880 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1881 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), clickRecognizerPtr);
1882 gestureScope->ForceCleanGestureScope();
1883 SUCCEED();
1884 }
1885
1886 /**
1887 * @tc.name: GestureRefereeOnAcceptGestureTest034
1888 * @tc.desc: Test GestureReferee OnAcceptGesture function
1889 */
1890 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest034, TestSize.Level1)
1891 {
1892 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1893 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1894 auto gestureRecognizer = AceType::DynamicCast<NGGestureRecognizer>(clickRecognizerPtr);
1895 gestureScope->recognizers_.emplace_back(gestureRecognizer);
1896 auto gesture = AceType::MakeRefPtr<NG::GestureReferee>();
1897 size_t id = 3;
1898 gesture->gestureScopes_.try_emplace(id, gestureScope);
1899 gesture->QueryAllDone(1);
1900 SUCCEED();
1901 }
1902
1903 /**
1904 * @tc.name: GestureRefereeOnAcceptGestureTest035
1905 * @tc.desc: Test GestureReferee OnAcceptGesture function
1906 */
1907 HWTEST_F(GestureRefereeTestNg, GestureRefereeOnAcceptGestureTest035, TestSize.Level1)
1908 {
1909 auto container = Container::Current();
1910 auto pipelineContext = container->GetPipelineContext();
1911 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1912 PanDirection panDirection;
1913 panDirection.type = PanDirection::VERTICAL;
1914 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>(1, panDirection, 0);
1915 std::vector<RefPtr<NGGestureRecognizer>> recognizers { panRecognizer };
1916 auto test = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1917 auto Ngg = AceType::DynamicCast<NG::NGGestureRecognizer>(test);
1918 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
1919 gestureScope->recognizers_.emplace_back(Ngg);
1920 gestureScope->recognizers_.emplace_back(nullptr);
1921 auto gesture = AceType::MakeRefPtr<NG::GestureReferee>();
1922 gesture->lastIsAxis_ = true;
1923 size_t id = 1;
1924 gesture->gestureScopes_.try_emplace(id, gestureScope);
1925 gesture->CleanRedundanceScope();
1926 SUCCEED();
1927 }
1928 } // namespace OHOS::Ace::NG