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
18 using namespace testing;
19 using namespace testing::ext;
20
21 namespace OHOS::Ace::NG {
22 class MockNGGestureRecognizer : public NGGestureRecognizer {
23 public:
24 MOCK_METHOD(void, ResetStatusOnFinish, (bool isBlocked), ());
BatchAdjudicate(const RefPtr<NGGestureRecognizer> & recognizer,GestureDisposal disposal)25 void BatchAdjudicate(const RefPtr<NGGestureRecognizer>& recognizer, GestureDisposal disposal) {}
OnBeginGestureReferee(int32_t touchId,bool needUpdateChild=false)26 void OnBeginGestureReferee(int32_t touchId, bool needUpdateChild = false) {}
HandleTouchDownEvent(const TouchEvent & event)27 void HandleTouchDownEvent(const TouchEvent& event) {}
HandleTouchUpEvent(const TouchEvent & event)28 void HandleTouchUpEvent(const TouchEvent& event) {}
HandleTouchMoveEvent(const TouchEvent & event)29 void HandleTouchMoveEvent(const TouchEvent& event) {}
HandleTouchCancelEvent(const TouchEvent & event)30 void HandleTouchCancelEvent(const TouchEvent& event) {}
HandleTouchDownEvent(const AxisEvent & event)31 void HandleTouchDownEvent(const AxisEvent& event) {}
HandleTouchUpEvent(const AxisEvent & event)32 void HandleTouchUpEvent(const AxisEvent& event) {}
HandleTouchMoveEvent(const AxisEvent & event)33 void HandleTouchMoveEvent(const AxisEvent& event) {}
HandleTouchCancelEvent(const AxisEvent & event)34 void HandleTouchCancelEvent(const AxisEvent& event) {}
OnResetStatus()35 void OnResetStatus() {}
OnSucceedCancel()36 void OnSucceedCancel() {}
OnAccepted()37 void OnAccepted() {}
OnRejected()38 void OnRejected() {}
CheckTouchId(int32_t touchId)39 bool CheckTouchId(int32_t touchId)
40 {
41 return false;
42 }
43 };
44 class GestureRecognizerTestNg : public GesturesCommonTestNg {
45 public:
46 static void SetUpTestSuite();
47 static void TearDownTestSuite();
48 };
49
SetUpTestSuite()50 void GestureRecognizerTestNg::SetUpTestSuite()
51 {
52 MockPipelineContext::SetUp();
53 }
54
TearDownTestSuite()55 void GestureRecognizerTestNg::TearDownTestSuite()
56 {
57 MockPipelineContext::TearDown();
58 }
59
60 /**
61 * @tc.name: TriggerGestureJudgeCallbackTest001
62 * @tc.desc: Test Recognizer function: TriggerGestureJudgeCallbackTest001
63 * @tc.type: FUNC
64 */
65 HWTEST_F(GestureRecognizerTestNg, TriggerGestureJudgeCallbackTest001, TestSize.Level1)
66 {
67 /**
68 * @tc.steps: step1. create Recognizer、TargetComponent.
69 */
70 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
71 RefPtr<LongPressRecognizer> longPressRecognizerPtr = AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
72 FINGER_NUMBER, false);
73 RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
74 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
75 RefPtr<PinchRecognizer> pinchRecognizerPtr = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER,
76 PINCH_GESTURE_DISTANCE);
77 RefPtr<RotationRecognizer> rotationRecognizerPtr =
78 AceType::MakeRefPtr<RotationRecognizer>(SINGLE_FINGER_NUMBER, ROTATION_GESTURE_ANGLE);
79 SwipeDirection swipeDirection;
80 RefPtr<SwipeRecognizer> swipeRecognizerPtr =
81 AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
82
83 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
84
__anonecf247780102(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 85 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
86 return GestureJudgeResult::REJECT;};
87 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
88 /**
89 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
90 * @tc.expected: step2. result equals CONTINUE.
91 */
92 clickRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
93 clickRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
94 auto result = clickRecognizerPtr->TriggerGestureJudgeCallback();
95 EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
96 longPressRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
97 longPressRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
98 result = longPressRecognizerPtr->TriggerGestureJudgeCallback();
99 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
100 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
101 result = panRecognizerPtr->TriggerGestureJudgeCallback();
102 pinchRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
103 pinchRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
104 result = pinchRecognizerPtr->TriggerGestureJudgeCallback();
105 rotationRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
106 rotationRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
107 result = rotationRecognizerPtr->TriggerGestureJudgeCallback();
108 swipeRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
109 swipeRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
110 result = swipeRecognizerPtr->TriggerGestureJudgeCallback();
111 EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
112 /**
113 * @tc.steps: step3. targetComponent_ is not null, call TriggerGestureJudgeCallback function and compare result.
114 * @tc.expected: step3. result equals PREVENT.
115 */
116 clickRecognizerPtr->targetComponent_ = targetComponent;
117 EXPECT_EQ(clickRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
118
119 longPressRecognizerPtr->targetComponent_ = targetComponent;
120 EXPECT_EQ(longPressRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
121
122 panRecognizerPtr->targetComponent_ = targetComponent;
123 EXPECT_EQ(panRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
124
125 pinchRecognizerPtr->targetComponent_ = targetComponent;
126 EXPECT_EQ(pinchRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
127
128 rotationRecognizerPtr->targetComponent_ = targetComponent;
129 EXPECT_EQ(rotationRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
130
131 swipeRecognizerPtr->targetComponent_ = targetComponent;
132 EXPECT_EQ(swipeRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
133 }
134
135 /**
136 * @tc.name: TransformTest001
137 * @tc.desc: Test Transform in Default Condition
138 */
139 HWTEST_F(GestureRecognizerTestNg, TransformTest001, TestSize.Level1)
140 {
141 /**
142 * @tc.steps: step1. create FrameNode.
143 */
144 RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
145 RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
146 RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
147 FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
148 FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
149
150 /**
151 * @tc.steps: step2. mock local matrix.
152 */
153 FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
154 FRAME_NODE_1->localMat_ = Matrix4::CreateIdentity();
155 FRAME_NODE_2->localMat_ = Matrix4::CreateIdentity();
156
157 /**
158 * @tc.steps: step2. call callback function.
159 */
160 PointF f1(1.0, 1.0);
161 NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
162 PointF f2(1.000000, 1.000000);
163 EXPECT_EQ(f1, f2);
164 }
165
166 /**
167 * @tc.name: TransformTest002
168 * @tc.desc: Test Transform with Matrix
169 */
170 HWTEST_F(GestureRecognizerTestNg, TransformTest002, TestSize.Level1)
171 {
172 /**
173 * @tc.steps: step1. create FrameNode.
174 */
175 RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
176 RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
177 RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
178 FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
179 FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
180
181 /**
182 * @tc.steps: step2. mock local matrix.
183 */
184 FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
185 FRAME_NODE_1->localMat_ = Matrix4::Invert(
186 Matrix4::CreateTranslate(100, 200, 0) * Matrix4::CreateRotate(90, 0, 0, 1) *
187 Matrix4::CreateScale(0.6, 0.8, 1));
188 FRAME_NODE_2->localMat_ = Matrix4::Invert(
189 Matrix4::CreateTranslate(400, 300, 0) * Matrix4::CreateRotate(30, 0, 0, 1) *
190 Matrix4::CreateScale(0.5, 0.5, 1));
191
192 /**
193 * @tc.steps: step3. call callback function.
194 */
195 PointF f1(1.0, 1.0);
196 NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
197 PointF f2(-1443.533813, 426.392731);
198 EXPECT_EQ(f1, f2);
199 }
200
201 /**
202 * @tc.name: TransformTest003
203 * @tc.desc: Test Transform with Matrix in Reverse Order
204 */
205 HWTEST_F(GestureRecognizerTestNg, TransformTest003, TestSize.Level1)
206 {
207 /**
208 * @tc.steps: step1. create FrameNode.
209 */
210 RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
211 RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
212 RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
213 FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
214 FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
215
216 /**
217 * @tc.steps: step2. mock local matrix.
218 */
219 FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
220 FRAME_NODE_2->localMat_ = Matrix4::Invert(
221 Matrix4::CreateTranslate(100, 200, 0) * Matrix4::CreateRotate(90, 0, 0, 1) *
222 Matrix4::CreateScale(0.6, 0.8, 1));
223 FRAME_NODE_1->localMat_ = Matrix4::Invert(
224 Matrix4::CreateTranslate(400, 300, 0) * Matrix4::CreateRotate(30, 0, 0, 1) *
225 Matrix4::CreateScale(0.5, 0.5, 1));
226
227 /**
228 * @tc.steps: step3. call callback function.
229 */
230 PointF f1(1.0, 1.0);
231 NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
232 PointF f2(-531.471924, 1362.610352);
233 EXPECT_EQ(f1, f2);
234 }
235
236 /**
237 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest001
238 * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
239 * @tc.type: FUNC
240 */
241 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
242 {
243 /**
244 * @tc.steps: step1. create and set Recognizer、TargetComponent.
245 */
246
247 RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
248 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
249 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anonecf247780202(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 250 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
251 return GestureJudgeResult::REJECT;};
252 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
253 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
254 PanDirection panDirection;
255 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
256 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
257 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
258 panRecognizerPtr->targetComponent_ = targetComponent;
259 panRecognizerPtr->targetComponent_->node_ = frameNode;
260 TouchEvent touchEvent;
261 touchEvent.tiltX.emplace(1.0f);
262 touchEvent.tiltY.emplace(1.0f);
263 panRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
264 panRecognizerPtr->direction_.type = PanDirection::ALL;
265 panRecognizerPtr->isFlushTouchEventsEnd_ = true;
266 panRecognizerPtr->averageDistance_ = Offset(0, -1);
267 panRecognizerPtr->distance_ = 0;
268 panRecognizerPtr->currentFingers_ = 1;
269 panRecognizerPtr->fingers_ = 1;
270
271 /**
272 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
273 * @tc.steps: case1: gestureInfo_ is nullptr touchEvent
274 * @tc.expected: step2. result equals REJECT.
275 */
276 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
277 panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
278 EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::NONE);
279
280 /**
281 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
282 * @tc.steps: case2: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
283 * isDragUserReject_ = true touchEvent
284 * @tc.expected: step2. result equals REJECT.
285 */
286 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
287 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
288 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
289 guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
290 AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
291 guestureEventHub->dragEventActuator_->isDragUserReject_ = true;
292 panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
293 EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::REJECT);
294
295 /**
296 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
297 * @tc.steps: case3: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
298 * isDragUserReject_ = false touchEvent
299 * @tc.expected: step2. isDragUserReject_ = true.
300 */
301 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
302 guestureEventHub->dragEventActuator_->isDragUserReject_ = false;
303 panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
304 EXPECT_TRUE(guestureEventHub->dragEventActuator_->isDragUserReject_);
305 }
306
307 /**
308 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest002
309 * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
310 * @tc.type: FUNC
311 */
312 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest002, TestSize.Level1)
313 {
314 /**
315 * @tc.steps: step1. create and set Recognizer、TargetComponent.
316 */
317 RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
318 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
319 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anonecf247780302(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 320 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
321 return GestureJudgeResult::REJECT;};
322 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
323 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
324 PanDirection panDirection;
325 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
326 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
327 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
328 panRecognizerPtr->targetComponent_ = targetComponent;
329 panRecognizerPtr->targetComponent_->node_ = frameNode;
330 TouchEvent touchEvent;
331 touchEvent.tiltX.emplace(1.0f);
332 touchEvent.tiltY.emplace(1.0f);
333 AxisEvent axisEvent;
334 panRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
335 panRecognizerPtr->direction_.type = PanDirection::ALL;
336 panRecognizerPtr->isFlushTouchEventsEnd_ = true;
337 panRecognizerPtr->averageDistance_ = Offset(0, -1);
338 panRecognizerPtr->distance_ = 0;
339 panRecognizerPtr->currentFingers_ = 1;
340 panRecognizerPtr->fingers_ = 1;
341
342 /**
343 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
344 * @tc.steps: case1: gestureInfo_ is nullptr axisEvent
345 * @tc.expected: step2. result equals REJECT.
346 */
347 panRecognizerPtr->inputEventType_ = InputEventType::AXIS;
348 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
349 panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
350 EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::NONE);
351
352 /**
353 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
354 * @tc.steps: case2: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
355 * isDragUserReject_ = true axisEvent
356 * @tc.expected: step2. result equals REJECT.
357 */
358 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
359 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
360 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
361 guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
362 AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
363 guestureEventHub->dragEventActuator_->isDragUserReject_ = true;
364 panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
365 EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::REJECT);
366
367 /**
368 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
369 * @tc.steps: case3: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
370 * isDragUserReject_ = false axisEvent
371 * @tc.expected: step2. isDragUserReject_ = true.
372 */
373 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
374 guestureEventHub->dragEventActuator_->isDragUserReject_ = false;
375 panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
376 EXPECT_TRUE(guestureEventHub->dragEventActuator_->isDragUserReject_);
377 }
378
379 class MockLongPressRecognizer : public LongPressRecognizer {
380 public:
MockLongPressRecognizer()381 MockLongPressRecognizer() : LongPressRecognizer(DURATION, FINGER_NUMBER) {}
382 MOCK_METHOD(void, HandleTouchUpEvent, (const TouchEvent&), (override));
383 MOCK_METHOD(void, HandleTouchCancelEvent, (const TouchEvent&), (override));
384 };
385
386 /**
387 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest003
388 * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
389 * @tc.type: FUNC
390 */
391 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest003, TestSize.Level1)
392 {
393 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(PINCH_GESTURE_DISTANCE, FINGER_NUMBER);
394 recognizerTest->fingersId_.insert(1);
395 recognizerTest->fingersId_.insert(2);
396 recognizerTest->fingersId_.insert(3);
397 recognizerTest->fingersId_.insert(4);
398 recognizerTest->fingersId_.insert(5);
399 recognizerTest->fingersId_.insert(6);
400 TouchEvent point;
401 point.type = TouchType::MOVE;
402 recognizerTest->HandleBridgeModeEvent(point);
403 point.type = TouchType::DOWN;
404 recognizerTest->HandleBridgeModeEvent(point);
405 point.sourceType = SourceType::MOUSE;
406 point.id = 4;
407 recognizerTest->HandleBridgeModeEvent(point);
408
409 point.type = TouchType::UP;
410 point.id = 2;
411 auto longPressRecoginzer = AceType::MakeRefPtr<MockLongPressRecognizer>();
412 longPressRecoginzer->fingersId_.clear();
413 longPressRecoginzer->fingersId_.insert(1);
414 longPressRecoginzer->fingersId_.insert(2);
415 longPressRecoginzer->fingersId_.insert(3);
416 longPressRecoginzer->fingersId_.insert(4);
417 EXPECT_CALL(*longPressRecoginzer, HandleTouchUpEvent(_)).WillRepeatedly(Return());
418 longPressRecoginzer->HandleBridgeModeEvent(point);
419 EXPECT_EQ(point.id, 2);
420 }
421
422 /**
423 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest004
424 * @tc.desc: Test PanPressRecognizer function: HandleBridgeModeEvent
425 * @tc.type: FUNC
426 */
427 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest004, TestSize.Level1)
428 {
429 auto longPressRecoginzer = AceType::MakeRefPtr<MockLongPressRecognizer>();
430 TouchEvent point;
431 point.type = TouchType::UP;
432 point.id = 8;
433 longPressRecoginzer->fingersId_.clear();
434 longPressRecoginzer->fingersId_.insert(1);
435 longPressRecoginzer->fingersId_.insert(2);
436 longPressRecoginzer->fingersId_.insert(3);
437 longPressRecoginzer->fingersId_.insert(4);
438 EXPECT_CALL(*longPressRecoginzer, HandleTouchUpEvent(_)).WillRepeatedly(Return());
439 longPressRecoginzer->HandleBridgeModeEvent(point);
440
441 point.type = TouchType::CANCEL;
442 longPressRecoginzer->fingersId_.clear();
443 longPressRecoginzer->fingersId_.insert(1);
444 longPressRecoginzer->fingersId_.insert(2);
445 longPressRecoginzer->fingersId_.insert(3);
446 longPressRecoginzer->fingersId_.insert(4);
447 point.id = 2;
448 EXPECT_CALL(*longPressRecoginzer, HandleTouchCancelEvent(_)).WillRepeatedly(Return());
449 longPressRecoginzer->HandleBridgeModeEvent(point);
450
451 point.type = TouchType::CANCEL;
452 longPressRecoginzer->fingersId_.clear();
453 longPressRecoginzer->fingersId_.insert(1);
454 longPressRecoginzer->fingersId_.insert(2);
455 longPressRecoginzer->fingersId_.insert(3);
456 longPressRecoginzer->fingersId_.insert(4);
457 point.id = 5;
458 EXPECT_CALL(*longPressRecoginzer, HandleTouchCancelEvent(_)).WillRepeatedly(Return());
459 longPressRecoginzer->HandleBridgeModeEvent(point);
460 point.type = TouchType::PULL_UP;
461 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(DURATION, FINGER_NUMBER);
462 recognizerTest->HandleBridgeModeEvent(point);
463 EXPECT_EQ(point.id, 5);
464 }
465
466 /**
467 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest005
468 * @tc.desc: Test PanPressRecognizer function: OnRejectBridgeObj
469 * @tc.type: FUNC
470 */
471 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest005, TestSize.Level1)
472 {
473 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(DURATION, FINGER_NUMBER);
474 recognizerTest->OnRejectBridgeObj();
475
476 WeakPtr<NGGestureRecognizer> bridgeObj = AceType::MakeRefPtr<MockNGGestureRecognizer>();
477 recognizerTest->bridgeObjList_.push_back(bridgeObj);
478 recognizerTest->OnRejectBridgeObj();
479 EXPECT_NE(recognizerTest->Dump(), nullptr);
480 }
481
482 /**
483 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest006
484 * @tc.desc: Test PanPressRecognizer function: HandleBridgeModeEvent
485 * @tc.type: FUNC
486 */
487 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest006, TestSize.Level1)
488 {
489 AxisEvent event;
490 auto longPressRecoginzer = AceType::MakeRefPtr<MockLongPressRecognizer>();
491 event.action = AxisAction::NONE;
492 longPressRecoginzer->HandleBridgeModeEvent(event);
493 event.action = AxisAction::BEGIN;
494 longPressRecoginzer->HandleBridgeModeEvent(event);
495 event.action = AxisAction::UPDATE;
496 longPressRecoginzer->HandleBridgeModeEvent(event);
497 event.action = AxisAction::END;
498 longPressRecoginzer->HandleBridgeModeEvent(event);
499 EXPECT_EQ(event.action, AxisAction::END);
500 }
501
502 /**
503 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest007
504 * @tc.desc: Test Dump
505 * @tc.type: FUNC
506 */
507 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest007, TestSize.Level1)
508 {
509 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(DURATION, FINGER_NUMBER);
510 EXPECT_NE(recognizerTest->Dump(), nullptr);
511 }
512
513 /**
514 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest008
515 * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
516 * @tc.type: FUNC
517 */
518 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest008, TestSize.Level1)
519 {
520 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(DURATION, FINGER_NUMBER);
521 RefPtr<NGGestureRecognizer> targetPtr1 = nullptr;
522 RefPtr<NGGestureRecognizer> targetPtr2 = nullptr;
523 std::list<RefPtr<NGGestureRecognizer>> responseLinkResult;
524 responseLinkResult.push_back(targetPtr1);
525 responseLinkResult.push_back(targetPtr2);
526 recognizerTest->SetResponseLinkRecognizers(responseLinkResult);
527 EXPECT_NE(recognizerTest->Dump(), nullptr);
528 }
529
530 /**
531 * @tc.name: GestureRecognizerHandleEvent001
532 * @tc.desc: Test GestureRecognizer function: AboutToAddCurrentFingers AboutToMinusCurrentFingers
533 * @tc.type: FUNC
534 */
535 HWTEST_F(GestureRecognizerTestNg, GestureRecognizerHandleEvent001, TestSize.Level1)
536 {
537 /**
538 * @tc.steps: step1. create ExclusiveRecognizer.
539 */
540 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
541 TouchEvent touchEvent;
542 bool result = false;
543
544 /**
545 * @tc.steps: step3. set currentFinger = 0, add touchEvent to gestureRecognizer.
546 * @tc.steps: case1: touchPoints is in recognizer region.
547 * @tc.expected: step3. func success, clickRecognizer currentFingers add.
548 */
549 clickRecognizerPtr->currentFingers_ = 0;
550 result = clickRecognizerPtr->AboutToAddCurrentFingers(touchEvent);
551 EXPECT_EQ(result, true);
552 EXPECT_EQ(clickRecognizerPtr->currentFingers_, 1);
553
554 /**
555 * @tc.steps: step3. set currentFinger = 1, delete touchEvent to gestureRecognizer.
556 * @tc.steps: case2: fingersId not find touchEvent id.
557 * @tc.expected: step3. func fail.
558 */
559 clickRecognizerPtr->currentFingers_ = 1;
560 result = clickRecognizerPtr->AboutToMinusCurrentFingers(0);
561 EXPECT_EQ(result, false);
562 EXPECT_EQ(clickRecognizerPtr->currentFingers_, 1);
563
564 /**
565 * @tc.steps: step3. set currentFinger = 1, delete touchEvent to gestureRecognizer.
566 * @tc.steps: case3: fingersId find touchEvent id.
567 * @tc.expected: step3. func success, currentFingers delete.
568 */
569 clickRecognizerPtr->currentFingers_ = 1;
570 clickRecognizerPtr->fingersId_.insert(0);
571 result = clickRecognizerPtr->AboutToMinusCurrentFingers(0);
572 EXPECT_EQ(result, true);
573 }
574 } // namespace OHOS::Ace::NG