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 ExclusiveRecognizerTestNg : public GesturesCommonTestNg {
22 public:
23 static void SetUpTestSuite();
24 static void TearDownTestSuite();
25 };
26
SetUpTestSuite()27 void ExclusiveRecognizerTestNg::SetUpTestSuite()
28 {
29 MockPipelineContext::SetUp();
30 }
31
TearDownTestSuite()32 void ExclusiveRecognizerTestNg::TearDownTestSuite()
33 {
34 MockPipelineContext::TearDown();
35 }
36
37 /**
38 * @tc.name: ExclusiveRecognizerHandleRejectDisposalTest002
39 * @tc.desc: Test ExclusiveRecognizer HandleRejectDisposal function
40 */
41 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandleRejectDisposalTest002, TestSize.Level1)
42 {
43 /**
44 * @tc.steps: step1. create GestureScope and clickRecognizer.
45 */
46 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
47
48 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
49 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
50
51 /**
52 * @tc.steps: step2. call Adjudicate function and compare result
53 * @tc.steps: case1: refereeState is FAIL
54 * @tc.steps: expected equal
55 */
56 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
57 exclusiveRecognizerPtr->HandleRejectDisposal(clickRecognizerPtr);
58 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 0);
59 }
60
61 /**
62 * @tc.name: ExclusiveRecognizerHandleRejectDisposalTest003
63 * @tc.desc: Test ExclusiveRecognizer HandleRejectDisposal function
64 */
65 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandleRejectDisposalTest003, TestSize.Level1)
66 {
67 /**
68 * @tc.steps: step1. create GestureScope and clickRecognizer.
69 */
70 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
71
72 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
73 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
74
75 /**
76 * @tc.steps: step2. call Adjudicate function and compare result
77 * @tc.steps: case1: refereeState is FAIL
78 * @tc.steps: expected equal
79 */
80 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
81 exclusiveRecognizerPtr->HandleRejectDisposal(clickRecognizerPtr);
82 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 0);
83 }
84
85 /**
86 * @tc.name: ExclusiveRecognizerHandleRejectDisposalTest005
87 * @tc.desc: Test ExclusiveRecognizer HandleRejectDisposal function
88 */
89 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandleRejectDisposalTest005, TestSize.Level1)
90 {
91 /**
92 * @tc.steps: step1. create GestureScope and clickRecognizer.
93 */
94 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
95
96 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
97 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
98
99 /**
100 * @tc.steps: step2. call Adjudicate function and compare result
101 * @tc.steps: case1: refereeState is FAIL
102 * @tc.steps: expected equal
103 */
104 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
105 exclusiveRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
106 exclusiveRecognizerPtr->HandleRejectDisposal(clickRecognizerPtr);
107 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 0);
108 }
109
110 /**
111 * @tc.name: ExclusiveRecognizerHandleRejectDisposalTest006
112 * @tc.desc: Test ExclusiveRecognizer HandleRejectDisposal function
113 */
114 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandleRejectDisposalTest006, TestSize.Level1)
115 {
116 /**
117 * @tc.steps: step1. create GestureScope and clickRecognizer.
118 */
119 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
120
121 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
122 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
123
124 /**
125 * @tc.steps: step2. call Adjudicate function and compare result
126 * @tc.steps: case1: refereeState is FAIL
127 * @tc.steps: expected equal
128 */
129 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
130 exclusiveRecognizerPtr->refereeState_ = RefereeState::PENDING;
131 exclusiveRecognizerPtr->HandleRejectDisposal(clickRecognizerPtr);
132 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 0);
133 }
134
135 /**
136 * @tc.name: ExclusiveRecognizerHandlePendingDisposalTest001
137 * @tc.desc: Test ExclusiveRecognizer HandlePendingDisposal function
138 */
139 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandlePendingDisposalTest001, TestSize.Level1)
140 {
141 /**
142 * @tc.steps: step1. create GestureScope and clickRecognizer.
143 */
144 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
145
146 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
147 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
148 clickRecognizerPtr2->refereeState_ = RefereeState::PENDING;
149 recognizers.insert(recognizers.end(), clickRecognizerPtr2);
150 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
151
152 /**
153 * @tc.steps: step2. call Adjudicate function and compare result
154 * @tc.steps: case1: refereeState is FAIL
155 * @tc.steps: expected equal
156 */
157 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
158 exclusiveRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
159 exclusiveRecognizerPtr->HandlePendingDisposal(clickRecognizerPtr);
160 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 1);
161 }
162
163 /**
164 * @tc.name: ExclusiveRecognizerHandleAcceptDisposalTest001
165 * @tc.desc: Test ExclusiveRecognizer HandleAcceptDisposal function
166 */
167 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandleAcceptDisposalTest001, TestSize.Level1)
168 {
169 /**
170 * @tc.steps: step1. create GestureScope and clickRecognizer.
171 */
172 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
173
174 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
175 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
176 clickRecognizerPtr2->refereeState_ = RefereeState::PENDING;
177 recognizers.insert(recognizers.end(), clickRecognizerPtr2);
178 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
179
180 /**
181 * @tc.steps: step2. call Adjudicate function and compare result
182 * @tc.steps: case1: refereeState is FAIL
183 * @tc.steps: expected equal
184 */
185 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
186 exclusiveRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
187 exclusiveRecognizerPtr->HandleAcceptDisposal(clickRecognizerPtr);
188 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 1);
189 }
190
191 /**
192 * @tc.name: ExclusiveRecognizerHandlePendingDisposalTest002
193 * @tc.desc: Test ExclusiveRecognizer HandlePendingDisposal function
194 */
195 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandlePendingDisposalTest002, TestSize.Level1)
196 {
197 /**
198 * @tc.steps: step1. create GestureScope and clickRecognizer.
199 */
200 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
201
202 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
203 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
204 clickRecognizerPtr2->refereeState_ = RefereeState::SUCCEED_BLOCKED;
205 recognizers.insert(recognizers.end(), clickRecognizerPtr2);
206 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
207
208 /**
209 * @tc.steps: step2. call Adjudicate function and compare result
210 * @tc.steps: case1: refereeState is FAIL
211 * @tc.steps: expected equal
212 */
213 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
214 exclusiveRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
215 exclusiveRecognizerPtr->HandlePendingDisposal(clickRecognizerPtr);
216 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 1);
217 }
218
219 /**
220 * @tc.name: ExclusiveRecognizerHandleAcceptDisposalTest002
221 * @tc.desc: Test ExclusiveRecognizer HandleAcceptDisposal function
222 */
223 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandleAcceptDisposalTest002, TestSize.Level1)
224 {
225 /**
226 * @tc.steps: step1. create GestureScope and clickRecognizer.
227 */
228 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
229
230 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
231 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
232 clickRecognizerPtr2->refereeState_ = RefereeState::SUCCEED_BLOCKED;
233 recognizers.insert(recognizers.end(), clickRecognizerPtr2);
234 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
235
236 /**
237 * @tc.steps: step2. call Adjudicate function and compare result
238 * @tc.steps: case1: refereeState is FAIL
239 * @tc.steps: expected equal
240 */
241 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
242 exclusiveRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
243 exclusiveRecognizerPtr->HandleAcceptDisposal(clickRecognizerPtr);
244 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 1);
245 }
246
247 /**
248 * @tc.name: ExclusiveRecognizerHandleRejectDisposalTest008
249 * @tc.desc: Test ExclusiveRecognizer HandleRejectDisposal function
250 */
251 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerHandleRejectDisposalTest008, TestSize.Level1)
252 {
253 /**
254 * @tc.steps: step1. create GestureScope and clickRecognizer.
255 */
256 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
257
258 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
259 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
260 clickRecognizerPtr2->refereeState_ = RefereeState::PENDING_BLOCKED;
261 recognizers.insert(recognizers.end(), clickRecognizerPtr2);
262 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
263
264 /**
265 * @tc.steps: step2. call Adjudicate function and compare result
266 * @tc.steps: case1: refereeState is FAIL
267 * @tc.steps: expected equal
268 */
269 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
270 exclusiveRecognizerPtr->refereeState_ = RefereeState::PENDING;
271 exclusiveRecognizerPtr->HandleRejectDisposal(clickRecognizerPtr);
272 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 1);
273
274 /**
275 * @tc.steps: step2. call Adjudicate function and compare result
276 * @tc.steps: case1: refereeState is FAIL
277 * @tc.steps: expected equal
278 */
279 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
280 exclusiveRecognizerPtr->refereeState_ = RefereeState::PENDING;
281 clickRecognizerPtr2->refereeState_ = RefereeState::SUCCEED_BLOCKED;
282 exclusiveRecognizerPtr->HandleRejectDisposal(clickRecognizerPtr);
283 EXPECT_EQ(exclusiveRecognizerPtr->recognizers_.size(), 1);
284 }
285
286 /**
287 * @tc.name: ExclusiveRecognizerTest001
288 * @tc.desc: Test ExclusiveRecognizer function: OnAccepted OnRejected OnPending OnBlocked
289 * @tc.type: FUNC
290 */
291 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerTest001, TestSize.Level1)
292 {
293 /**
294 * @tc.steps: step1. create ExclusiveRecognizer.
295 */
296 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
297 ExclusiveRecognizer exclusiveRecognizer = ExclusiveRecognizer(recognizers);
298 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
299 RefPtr<ClickRecognizer> clickRecognizerPtrNotSame = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
300
301 /**
302 * @tc.steps: step2. call OnAccepted function and compare result.
303 * @tc.steps: case1: no active, no recognizers
304 * @tc.expected: step2. result equals.
305 */
306 exclusiveRecognizer.OnAccepted();
307 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED);
308
309 /**
310 * @tc.steps: step2. call OnAccepted function and compare result.
311 * @tc.steps: case2: has active, recognizers has nullptr
312 * @tc.expected: step2. result equals.
313 */
314 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
315 exclusiveRecognizer.recognizers_.push_back(nullptr);
316 exclusiveRecognizer.OnAccepted();
317 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED);
318
319 /**
320 * @tc.steps: step2. call OnAccepted function and compare result.
321 * @tc.steps: case3: has active, recognizers has ptr not same
322 * @tc.expected: step2. result equals.
323 */
324 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
325 exclusiveRecognizer.recognizers_.clear();
326 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtrNotSame);
327 exclusiveRecognizer.OnAccepted();
328 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED);
329
330 /**
331 * @tc.steps: step2. call OnAccepted function and compare result.
332 * @tc.steps: case4: has active, recognizers has ptr same
333 * @tc.expected: step2. result equals.
334 */
335 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
336 exclusiveRecognizer.recognizers_.clear();
337 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
338 exclusiveRecognizer.OnAccepted();
339 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED);
340
341 /**
342 * @tc.steps: step3. call OnRejected function and compare result.
343 * @tc.steps: case1: no recognizers
344 * @tc.expected: step3. result equals.
345 */
346 exclusiveRecognizer.recognizers_.clear();
347 exclusiveRecognizer.OnRejected();
348 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED);
349
350 /**
351 * @tc.steps: step3. call OnRejected function and compare result.
352 * @tc.steps: case2: recognizers has nullptr
353 * @tc.expected: step3. result equals.
354 */
355 exclusiveRecognizer.recognizers_.clear();
356 exclusiveRecognizer.recognizers_.push_back(nullptr);
357 exclusiveRecognizer.OnRejected();
358 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED);
359
360 /**
361 * @tc.steps: step3. call OnRejected function and compare result.
362 * @tc.steps: case3: recognizers has ptr, referee is not FAIL
363 * @tc.expected: step3. result equals.
364 */
365 exclusiveRecognizer.recognizers_.clear();
366 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
367 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
368 exclusiveRecognizer.OnRejected();
369 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED);
370
371 /**
372 * @tc.steps: step3. call OnRejected function and compare result.
373 * @tc.steps: case4: recognizers has ptr, referee is FAIL
374 * @tc.expected: step3. result equals.
375 */
376 exclusiveRecognizer.recognizers_.clear();
377 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
378 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
379 exclusiveRecognizer.OnRejected();
380 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED);
381 }
382
383 /**
384 * @tc.name: ExclusiveRecognizerTest002
385 * @tc.desc: Test ExclusiveRecognizer function: HandleEvent OnResetStatus
386 * @tc.type: FUNC
387 */
388 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerTest002, TestSize.Level1)
389 {
390 /**
391 * @tc.steps: step1. create ExclusiveRecognizer.
392 */
393 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
394 ExclusiveRecognizer exclusiveRecognizer = ExclusiveRecognizer(recognizers);
395
396 /**
397 * @tc.steps: step2. create touchEvent and call HandleEvent function and compare result.
398 * @tc.steps: case1: active is nullptr, recognizers is empty
399 * @tc.expected: step2. result equals.
400 */
401 bool result = false;
402 TouchEvent touchEvent;
403 touchEvent.type = TouchType::MOVE;
404 result = exclusiveRecognizer.HandleEvent(touchEvent);
405 EXPECT_EQ(result, true);
406 touchEvent.type = TouchType::DOWN;
407 result = exclusiveRecognizer.HandleEvent(touchEvent);
408 EXPECT_EQ(result, true);
409 touchEvent.type = TouchType::UP;
410 result = exclusiveRecognizer.HandleEvent(touchEvent);
411 EXPECT_EQ(result, true);
412 touchEvent.type = TouchType::CANCEL;
413 result = exclusiveRecognizer.HandleEvent(touchEvent);
414 EXPECT_EQ(result, true);
415 touchEvent.type = TouchType::UNKNOWN;
416 result = exclusiveRecognizer.HandleEvent(touchEvent);
417 EXPECT_EQ(result, true);
418
419 /**
420 * @tc.steps: step2. create touchEvent and call HandleEvent function and compare result.
421 * @tc.steps: case2: active is not nullptr, checkTouchId is false
422 * @tc.expected: step2. result equals.
423 */
424 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
425 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
426 touchEvent.type = TouchType::DOWN;
427 result = exclusiveRecognizer.HandleEvent(touchEvent);
428 EXPECT_EQ(result, true);
429
430 /**
431 * @tc.steps: step2. create touchEvent and call HandleEvent function and compare result.
432 * @tc.steps: case3: active is not nullptr, checkTouchId is true
433 * @tc.expected: step2. result equals.
434 */
435 clickRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
436 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
437 result = exclusiveRecognizer.HandleEvent(touchEvent);
438 EXPECT_EQ(result, true);
439
440 /**
441 * @tc.steps: step2. create touchEvent and call HandleEvent function and compare result.
442 * @tc.steps: case4: active is nullptr, recognizers have nullptr
443 * @tc.expected: step2. result equals.
444 */
445 exclusiveRecognizer.activeRecognizer_ = nullptr;
446 exclusiveRecognizer.recognizers_.clear();
447 exclusiveRecognizer.recognizers_.push_back(nullptr);
448 result = exclusiveRecognizer.HandleEvent(touchEvent);
449 EXPECT_EQ(result, true);
450
451 /**
452 * @tc.steps: step2. create touchEvent and call HandleEvent function and compare result.
453 * @tc.steps: case5: active is nullptr, recognizers have ptr, ptr not check
454 * @tc.expected: step2. result equals.
455 */
456 clickRecognizerPtr->touchPoints_.clear();
457 exclusiveRecognizer.recognizers_.clear();
458 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
459 result = exclusiveRecognizer.HandleEvent(touchEvent);
460 EXPECT_EQ(result, true);
461
462 /**
463 * @tc.steps: step2. create touchEvent and call HandleEvent function and compare result.
464 * @tc.steps: case6: active is nullptr, recognizers have ptr, ptr check
465 * @tc.expected: step2. result equals.
466 */
467 clickRecognizerPtr->touchPoints_.clear();
468 clickRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
469 exclusiveRecognizer.recognizers_.clear();
470 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
471 result = exclusiveRecognizer.HandleEvent(touchEvent);
472 EXPECT_EQ(result, true);
473 }
474
475 /**
476 * @tc.name: ExclusiveRecognizerTest003
477 * @tc.desc: Test ExclusiveRecognizer function: CheckNeedBlocked
478 * @tc.type: FUNC
479 */
480 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerTest003, TestSize.Level1)
481 {
482 /**
483 * @tc.steps: step1. create ExclusiveRecognizer.
484 */
485 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
486 ExclusiveRecognizer exclusiveRecognizer = ExclusiveRecognizer(recognizers);
487
488 /**
489 * @tc.steps: step2. call CheckNeedBlocked function and compare result.
490 * @tc.steps: case1: recognizers is empty
491 * @tc.expected: step2. result equals.
492 */
493 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
494 auto result = exclusiveRecognizer.CheckNeedBlocked(clickRecognizerPtr);
495 EXPECT_EQ(result, false);
496
497 /**
498 * @tc.steps: step2. call CheckNeedBlocked function and compare result.
499 * @tc.steps: case2: recognizers is not empty, child == recognizer
500 * @tc.expected: step2. result equals.
501 */
502 exclusiveRecognizer.recognizers_.clear();
503 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
504 result = exclusiveRecognizer.CheckNeedBlocked(clickRecognizerPtr);
505 EXPECT_EQ(result, false);
506
507 /**
508 * @tc.steps: step2. call CheckNeedBlocked function and compare result.
509 * @tc.steps: case3: recognizers is not empty, child is nullptr
510 * @tc.expected: step2. result equals.
511 */
512 exclusiveRecognizer.recognizers_.clear();
513 exclusiveRecognizer.recognizers_.push_back(nullptr);
514 result = exclusiveRecognizer.CheckNeedBlocked(clickRecognizerPtr);
515 EXPECT_EQ(result, false);
516
517 /**
518 * @tc.steps: step2. call CheckNeedBlocked function and compare result.
519 * @tc.steps: case3: recognizers is not empty, child is ptr, refeeState not PENDING
520 * @tc.expected: step2. result equals.
521 */
522 RefPtr<ClickRecognizer> clickRecognizerPtrNotSame = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
523 clickRecognizerPtrNotSame->refereeState_ = RefereeState::SUCCEED;
524 exclusiveRecognizer.recognizers_.clear();
525 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtrNotSame);
526 result = exclusiveRecognizer.CheckNeedBlocked(clickRecognizerPtr);
527 EXPECT_EQ(result, false);
528
529 /**
530 * @tc.steps: step2. call CheckNeedBlocked function and compare result.
531 * @tc.steps: case4: recognizers is not empty, child is ptr, refeeState PENDING
532 * @tc.expected: step2. result equals.
533 */
534 clickRecognizerPtrNotSame->refereeState_ = RefereeState::PENDING;
535 exclusiveRecognizer.recognizers_.clear();
536 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtrNotSame);
537 result = exclusiveRecognizer.CheckNeedBlocked(clickRecognizerPtr);
538 EXPECT_EQ(result, true);
539 }
540
541 /**
542 * @tc.name: ExclusiveRecognizerTest004
543 * @tc.desc: Test ExclusiveRecognizer function: UnBlockGesture
544 * @tc.type: FUNC
545 */
546 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerTest004, TestSize.Level1)
547 {
548 /**
549 * @tc.steps: step1. create ExclusiveRecognizer.
550 */
551 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
552 ExclusiveRecognizer exclusiveRecognizer = ExclusiveRecognizer(recognizers);
553
554 /**
555 * @tc.steps: step2. call UnBlockGesture function and compare result.
556 * @tc.expected: step2. result equals.
557 */
558 auto result = exclusiveRecognizer.UnBlockGesture();
559 EXPECT_EQ(result, nullptr);
560
561 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
562 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED_BLOCKED;
563 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
564 result = exclusiveRecognizer.UnBlockGesture();
565 EXPECT_EQ(result, true);
566 }
567
568 /**
569 * @tc.name: ExclusiveRecognizerTest005
570 * @tc.desc: Test ExclusiveRecognizer function: BatchAdjudicate, and GestureDisposal
571 * @tc.type: FUNC
572 */
573 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerTest005, TestSize.Level1)
574 {
575 /**
576 * @tc.steps: step1. create ExclusiveRecognizer.
577 */
578 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
579 ExclusiveRecognizer exclusiveRecognizer = ExclusiveRecognizer(recognizers);
580 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
581
582 /**
583 * @tc.steps: step2. call GestureDisposal function and compare result.
584 * @tc.steps: case1: refereeState_ is SUCCESS, return
585 * @tc.expected: step2. result equals.
586 */
587 exclusiveRecognizer.refereeState_ = RefereeState::SUCCEED;
588 exclusiveRecognizer.BatchAdjudicate(clickRecognizerPtr, GestureDisposal::ACCEPT);
589 EXPECT_EQ(exclusiveRecognizer.activeRecognizer_, nullptr);
590
591 /**
592 * @tc.steps: step2. call GestureDisposal function and compare result.
593 * @tc.steps: case2: GestureDisposal::ACCEPT, recognizer is SUCCESS
594 * @tc.expected: step2. result equals.
595 */
596 exclusiveRecognizer.refereeState_ = RefereeState::PENDING;
597 clickRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
598 exclusiveRecognizer.BatchAdjudicate(clickRecognizerPtr, GestureDisposal::ACCEPT);
599 EXPECT_EQ(exclusiveRecognizer.activeRecognizer_, nullptr);
600
601 /**
602 * @tc.steps: step2. call GestureDisposal function and compare result.
603 * @tc.steps: case3: GestureDisposal::PENDING, recognizer is PENDING
604 * @tc.expected: step2. result equals.
605 */
606 exclusiveRecognizer.refereeState_ = RefereeState::PENDING;
607 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
608 exclusiveRecognizer.BatchAdjudicate(clickRecognizerPtr, GestureDisposal::PENDING);
609 EXPECT_EQ(exclusiveRecognizer.activeRecognizer_, nullptr);
610
611 /**
612 * @tc.steps: step2. call GestureDisposal function and compare result.
613 * @tc.steps: case4: GestureDisposal::REJECT, recognizer is FAIL
614 * @tc.expected: step2. result equals.
615 */
616 exclusiveRecognizer.refereeState_ = RefereeState::PENDING;
617 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
618 exclusiveRecognizer.BatchAdjudicate(clickRecognizerPtr, GestureDisposal::NONE);
619 EXPECT_EQ(exclusiveRecognizer.activeRecognizer_, nullptr);
620
621 /**
622 * @tc.steps: step2. call GestureDisposal function and compare result.
623 * @tc.steps: case4: GestureDisposal::REJECT, recognizer is FAIL
624 * @tc.expected: step2. result equals.
625 */
626 exclusiveRecognizer.refereeState_ = RefereeState::PENDING;
627 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
628 exclusiveRecognizer.BatchAdjudicate(clickRecognizerPtr, GestureDisposal::REJECT);
629 EXPECT_EQ(exclusiveRecognizer.activeRecognizer_, nullptr);
630 }
631
632 /**
633 * @tc.name: ExclusiveRecognizerTest006
634 * @tc.desc: Test ExclusiveRecognizer function: ReconcileFrom
635 * @tc.type: FUNC
636 */
637 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerTest006, TestSize.Level1)
638 {
639 /**
640 * @tc.steps: step1. create ClickRecognizer.
641 */
642 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
643 ExclusiveRecognizer exclusiveRecognizer = ExclusiveRecognizer(recognizers);
644 RefPtr<ExclusiveRecognizer> exclusiveRecognizerPtr = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
645
646 /**
647 * @tc.steps: step2. call ReconcileFrom function and compare result.
648 * @tc.steps: case1: normal case
649 * @tc.expected: step2. result equals.
650 */
651 auto result = exclusiveRecognizer.ReconcileFrom(exclusiveRecognizerPtr);
652 EXPECT_EQ(result, true);
653
654 /**
655 * @tc.steps: step2. call ReconcileFrom function and compare result.
656 * @tc.steps: case2: recognizerPtr is nullptr
657 * @tc.expected: step2. result equals.
658 */
659 result = exclusiveRecognizer.ReconcileFrom(nullptr);
660 EXPECT_EQ(result, false);
661
662 /**
663 * @tc.steps: step2. call ReconcileFrom function and compare result.
664 * @tc.steps: case3: recognizerPtr size not same
665 * @tc.expected: step2. result equals.
666 */
667 exclusiveRecognizer.recognizers_.push_back(nullptr);
668 result = exclusiveRecognizer.ReconcileFrom(exclusiveRecognizerPtr);
669 EXPECT_EQ(result, false);
670
671 /**
672 * @tc.steps: step2. call ReconcileFrom function and compare result.
673 * @tc.steps: case4: recognizerPtr size not same, priorityMask not same
674 * @tc.expected: step2. result equals.
675 */
676 exclusiveRecognizer.priorityMask_ = GestureMask::End;
677 result = exclusiveRecognizer.ReconcileFrom(exclusiveRecognizerPtr);
678 EXPECT_EQ(result, false);
679
680 /**
681 * @tc.steps: step2. call ReconcileFrom function and compare result.
682 * @tc.steps: case5: recognizerPtr size same, priorityMask not same
683 * @tc.expected: step2. result equals.
684 */
685 exclusiveRecognizer.recognizers_.clear();
686 exclusiveRecognizerPtr->recognizers_.clear();
687 result = exclusiveRecognizer.ReconcileFrom(exclusiveRecognizerPtr);
688 EXPECT_EQ(result, false);
689
690 /**
691 * @tc.steps: step2. call ReconcileFrom function and compare result.
692 * @tc.steps: case6: recognizerPtr same, child is nullptr
693 * @tc.expected: step2. result equals.
694 */
695 exclusiveRecognizer.priorityMask_ = exclusiveRecognizerPtr->priorityMask_;
696 exclusiveRecognizer.recognizers_.clear();
697 exclusiveRecognizer.recognizers_.push_back(nullptr);
698 exclusiveRecognizerPtr->recognizers_.clear();
699 exclusiveRecognizerPtr->recognizers_.push_back(nullptr);
700 result = exclusiveRecognizer.ReconcileFrom(exclusiveRecognizerPtr);
701 EXPECT_EQ(result, false);
702
703 /**
704 * @tc.steps: step2. call ReconcileFrom function and compare result.
705 * @tc.steps: case6: recognizerPtr same, child is nullptr
706 * @tc.expected: step2. result equals.
707 */
708 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
709 exclusiveRecognizer.priorityMask_ = exclusiveRecognizerPtr->priorityMask_;
710 exclusiveRecognizer.recognizers_.clear();
711 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
712 exclusiveRecognizerPtr->recognizers_.clear();
713 exclusiveRecognizerPtr->recognizers_.push_back(clickRecognizerPtr);
714 result = exclusiveRecognizer.ReconcileFrom(exclusiveRecognizerPtr);
715 EXPECT_EQ(result, true);
716
717 /**
718 * @tc.steps: step2. call ReconcileFrom function and compare result.
719 * @tc.steps: case6: recognizerPtr same, child is nullptr
720 * @tc.expected: step2. result equals.
721 */
722 RefPtr<ClickRecognizer> clickRecognizerPtrNotSame =
723 AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER - 1, COUNT - 1);
724 exclusiveRecognizer.priorityMask_ = exclusiveRecognizerPtr->priorityMask_;
725 exclusiveRecognizer.recognizers_.clear();
726 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
727 exclusiveRecognizerPtr->recognizers_.clear();
728 exclusiveRecognizerPtr->recognizers_.push_back(clickRecognizerPtrNotSame);
729 result = exclusiveRecognizer.ReconcileFrom(exclusiveRecognizerPtr);
730 EXPECT_EQ(result, false);
731 }
732
733 /**
734 * @tc.name: ExclusiveRecognizerTest007
735 * @tc.desc: Test ExclusiveRecognizer function: OnPending OnBlocked
736 * @tc.type: FUNC
737 */
738 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerTest007, TestSize.Level1)
739 {
740 /**
741 * @tc.steps: step1. create ExclusiveRecognizer.
742 */
743 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
744 ExclusiveRecognizer exclusiveRecognizer = ExclusiveRecognizer(recognizers);
745 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
746 RefPtr<ClickRecognizer> clickRecognizerPtrNotSame = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
747
748 /**
749 * @tc.steps: step3. call OnRejected function and compare result.
750 * @tc.steps: case4: recognizers has ptr, referee is FAIL
751 * @tc.expected: step3. result equals.
752 */
753 exclusiveRecognizer.recognizers_.clear();
754 clickRecognizerPtr->refereeState_ = RefereeState::FAIL;
755 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
756 exclusiveRecognizer.OnRejected();
757 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::FAIL);
758
759 /**
760 * @tc.steps: step4. call OnPending function and compare result.
761 * @tc.steps: case1: no active
762 * @tc.expected: step4. result equals.
763 */
764 exclusiveRecognizer.activeRecognizer_ = nullptr;
765 exclusiveRecognizer.OnPending();
766 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::PENDING);
767
768 /**
769 * @tc.steps: step4. call OnPending function and compare result.
770 * @tc.steps: case2: has active
771 * @tc.expected: step4. result equals.
772 */
773 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
774 exclusiveRecognizer.OnPending();
775 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::PENDING);
776
777 /**
778 * @tc.steps: step5. call OnBlocked function and compare result.
779 * @tc.steps: case1: ACCEPT, no active
780 * @tc.expected: step5. result equals.
781 */
782 exclusiveRecognizer.disposal_ = GestureDisposal::ACCEPT;
783 exclusiveRecognizer.activeRecognizer_ = nullptr;
784 exclusiveRecognizer.OnBlocked();
785 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED_BLOCKED);
786
787 /**
788 * @tc.steps: step5. call OnBlocked function and compare result.
789 * @tc.steps: case2: ACCEPT, active
790 * @tc.expected: step5. result equals.
791 */
792 exclusiveRecognizer.disposal_ = GestureDisposal::ACCEPT;
793 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
794 exclusiveRecognizer.OnBlocked();
795 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::SUCCEED_BLOCKED);
796
797 /**
798 * @tc.steps: step5. call OnBlocked function and compare result.
799 * @tc.steps: case3: PENDING, no active
800 * @tc.expected: step5. result equals.
801 */
802 exclusiveRecognizer.disposal_ = GestureDisposal::PENDING;
803 exclusiveRecognizer.activeRecognizer_ = nullptr;
804 exclusiveRecognizer.OnBlocked();
805 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::PENDING_BLOCKED);
806
807 /**
808 * @tc.steps: step5. call OnBlocked function and compare result.
809 * @tc.steps: case3: PENDING, active
810 * @tc.expected: step5. result equals.
811 */
812 exclusiveRecognizer.disposal_ = GestureDisposal::REJECT;
813 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
814 exclusiveRecognizer.OnBlocked();
815 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::PENDING_BLOCKED);
816
817 /**
818 * @tc.steps: step5. call OnBlocked function and compare result.
819 * @tc.steps: case3: PENDING, active
820 * @tc.expected: step5. result equals.
821 */
822 exclusiveRecognizer.disposal_ = GestureDisposal::PENDING;
823 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
824 exclusiveRecognizer.OnBlocked();
825 EXPECT_EQ(exclusiveRecognizer.refereeState_, RefereeState::PENDING_BLOCKED);
826 }
827
828 /**
829 * @tc.name: ExclusiveRecognizerTest008
830 * @tc.desc: Test ExclusiveRecognizer function: HandleEvent OnResetStatus
831 * @tc.type: FUNC
832 */
833 HWTEST_F(ExclusiveRecognizerTestNg, ExclusiveRecognizerTest008, TestSize.Level1)
834 {
835 /**
836 * @tc.steps: step1. create ExclusiveRecognizer.
837 */
838 std::vector<RefPtr<NGGestureRecognizer>> recognizers = {};
839 ExclusiveRecognizer exclusiveRecognizer = ExclusiveRecognizer(recognizers);
840 bool result = false;
841 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
842
843 /**
844 * @tc.steps: step3. create axisEvent and call HandleEvent function and compare result.
845 * @tc.steps: case1: active is nullptr, recognizers is empty
846 * @tc.expected: step3. result equals.
847 */
848 AxisEvent axisEvent;
849 axisEvent.action = AxisAction::BEGIN;
850 result = exclusiveRecognizer.HandleEvent(axisEvent);
851 EXPECT_EQ(result, true);
852 axisEvent.action = AxisAction::UPDATE;
853 result = exclusiveRecognizer.HandleEvent(axisEvent);
854 EXPECT_EQ(result, true);
855 axisEvent.action = AxisAction::END;
856 result = exclusiveRecognizer.HandleEvent(axisEvent);
857 EXPECT_EQ(result, true);
858 axisEvent.action = AxisAction::NONE;
859 result = exclusiveRecognizer.HandleEvent(axisEvent);
860 EXPECT_EQ(result, true);
861
862 /**
863 * @tc.steps: step3. create axisEvent and call HandleEvent function and compare result.
864 * @tc.steps: case2: active is ptr
865 * @tc.expected: step3. result equals.
866 */
867 exclusiveRecognizer.activeRecognizer_ = clickRecognizerPtr;
868 result = exclusiveRecognizer.HandleEvent(axisEvent);
869 EXPECT_EQ(result, true);
870
871 /**
872 * @tc.steps: step3. create axisEvent and call HandleEvent function and compare result.
873 * @tc.steps: case3: active is nullptr, recognizers have nullptr
874 * @tc.expected: step3. result equals.
875 */
876 exclusiveRecognizer.activeRecognizer_ = nullptr;
877 exclusiveRecognizer.recognizers_.clear();
878 exclusiveRecognizer.recognizers_.push_back(nullptr);
879 result = exclusiveRecognizer.HandleEvent(axisEvent);
880 EXPECT_EQ(result, true);
881
882 /**
883 * @tc.steps: step3. create axisEvent and call HandleEvent function and compare result.
884 * @tc.steps: case4: active is nullptr, recognizers have ptr
885 * @tc.expected: step3. result equals.
886 */
887 exclusiveRecognizer.activeRecognizer_ = nullptr;
888 exclusiveRecognizer.recognizers_.clear();
889 exclusiveRecognizer.recognizers_.push_back(clickRecognizerPtr);
890 result = exclusiveRecognizer.HandleEvent(axisEvent);
891 EXPECT_EQ(result, true);
892
893 /**
894 * @tc.steps: step4. call OnResetStatus function and compare result.
895 * @tc.expected: step4. result equals.
896 */
897 exclusiveRecognizer.OnResetStatus();
898 EXPECT_EQ(exclusiveRecognizer.activeRecognizer_, nullptr);
899 axisEvent.action = AxisAction::CANCEL;
900 result = exclusiveRecognizer.HandleEvent(axisEvent);
901 EXPECT_EQ(result, true);
902 }
903 } // namespace OHOS::Ace::NG