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 "core/components_ng/base/observer_handler.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21
22 namespace OHOS::Ace::NG {
23 class MockNGGestureRecognizer : public NGGestureRecognizer {
24 public:
25 MOCK_METHOD(void, ResetStatusOnFinish, (bool isBlocked), ());
BatchAdjudicate(const RefPtr<NGGestureRecognizer> & recognizer,GestureDisposal disposal)26 void BatchAdjudicate(const RefPtr<NGGestureRecognizer>& recognizer, GestureDisposal disposal) {}
OnBeginGestureReferee(int32_t touchId,bool needUpdateChild=false)27 void OnBeginGestureReferee(int32_t touchId, bool needUpdateChild = false) {}
HandleTouchDownEvent(const TouchEvent & event)28 void HandleTouchDownEvent(const TouchEvent& event) {}
HandleTouchUpEvent(const TouchEvent & event)29 void HandleTouchUpEvent(const TouchEvent& event) {}
HandleTouchMoveEvent(const TouchEvent & event)30 void HandleTouchMoveEvent(const TouchEvent& event) {}
HandleTouchCancelEvent(const TouchEvent & event)31 void HandleTouchCancelEvent(const TouchEvent& event) {}
HandleTouchDownEvent(const AxisEvent & event)32 void HandleTouchDownEvent(const AxisEvent& event) {}
HandleTouchUpEvent(const AxisEvent & event)33 void HandleTouchUpEvent(const AxisEvent& event) {}
HandleTouchMoveEvent(const AxisEvent & event)34 void HandleTouchMoveEvent(const AxisEvent& event) {}
HandleTouchCancelEvent(const AxisEvent & event)35 void HandleTouchCancelEvent(const AxisEvent& event) {}
OnResetStatus()36 void OnResetStatus() {}
OnSucceedCancel()37 void OnSucceedCancel() {}
OnAccepted()38 void OnAccepted() {}
OnRejected()39 void OnRejected() {}
CheckTouchId(int32_t touchId)40 bool CheckTouchId(int32_t touchId)
41 {
42 return false;
43 }
GetTouchPoints()44 std::map<int32_t, TouchEvent> GetTouchPoints()
45 {
46 std::map<int32_t, TouchEvent> emptyTouchPoints;
47 return emptyTouchPoints;
48 }
49 };
50 class GestureRecognizerTestNg : public GesturesCommonTestNg {
51 public:
52 static void SetUpTestSuite();
53 static void TearDownTestSuite();
54 };
55
SetUpTestSuite()56 void GestureRecognizerTestNg::SetUpTestSuite()
57 {
58 MockPipelineContext::SetUp();
59 }
60
TearDownTestSuite()61 void GestureRecognizerTestNg::TearDownTestSuite()
62 {
63 MockPipelineContext::TearDown();
64 }
65
66 /**
67 * @tc.name: TriggerGestureJudgeCallbackTest001
68 * @tc.desc: Test Recognizer function: TriggerGestureJudgeCallbackTest001
69 * @tc.type: FUNC
70 */
71 HWTEST_F(GestureRecognizerTestNg, TriggerGestureJudgeCallbackTest001, TestSize.Level1)
72 {
73 /**
74 * @tc.steps: step1. create Recognizer、TargetComponent.
75 */
76 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
77 RefPtr<LongPressRecognizer> longPressRecognizerPtr = AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
78 FINGER_NUMBER, false);
79 RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
80 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
81 RefPtr<PinchRecognizer> pinchRecognizerPtr = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER,
82 PINCH_GESTURE_DISTANCE);
83 RefPtr<RotationRecognizer> rotationRecognizerPtr =
84 AceType::MakeRefPtr<RotationRecognizer>(SINGLE_FINGER_NUMBER, ROTATION_GESTURE_ANGLE);
85 SwipeDirection swipeDirection;
86 RefPtr<SwipeRecognizer> swipeRecognizerPtr =
87 AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
88
89 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
90
__anon6d6d5dda0102(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 91 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
92 return GestureJudgeResult::REJECT;};
93 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
94 /**
95 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
96 * @tc.expected: step2. result equals CONTINUE.
97 */
98 clickRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
99 clickRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
100 auto result = clickRecognizerPtr->TriggerGestureJudgeCallback();
101 EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
102 longPressRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
103 longPressRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
104 result = longPressRecognizerPtr->TriggerGestureJudgeCallback();
105 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
106 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
107 result = panRecognizerPtr->TriggerGestureJudgeCallback();
108 pinchRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
109 pinchRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
110 result = pinchRecognizerPtr->TriggerGestureJudgeCallback();
111 rotationRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
112 rotationRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
113 result = rotationRecognizerPtr->TriggerGestureJudgeCallback();
114 swipeRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
115 swipeRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
116 result = swipeRecognizerPtr->TriggerGestureJudgeCallback();
117 EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
118 /**
119 * @tc.steps: step3. targetComponent_ is not null, call TriggerGestureJudgeCallback function and compare result.
120 * @tc.expected: step3. result equals PREVENT.
121 */
122 clickRecognizerPtr->targetComponent_ = targetComponent;
123 EXPECT_EQ(clickRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
124
125 longPressRecognizerPtr->targetComponent_ = targetComponent;
126 EXPECT_EQ(longPressRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
127
128 panRecognizerPtr->targetComponent_ = targetComponent;
129 EXPECT_EQ(panRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
130
131 pinchRecognizerPtr->targetComponent_ = targetComponent;
132 EXPECT_EQ(pinchRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
133
134 rotationRecognizerPtr->targetComponent_ = targetComponent;
135 EXPECT_EQ(rotationRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
136
137 swipeRecognizerPtr->targetComponent_ = targetComponent;
138 EXPECT_EQ(swipeRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
139 }
140
141 /**
142 * @tc.name: TriggerGestureJudgeCallbackTest002
143 * @tc.desc: Test Recognizer function: TriggerGestureJudgeCallbackTest002
144 * @tc.type: FUNC
145 */
146 HWTEST_F(GestureRecognizerTestNg, TriggerGestureJudgeCallbackTest002, TestSize.Level1)
147 {
148 /**
149 * @tc.steps: step1. create Recognizer、TargetComponent.
150 */
151 RefPtr<RotationRecognizer> rotationRecognizerPtr =
152 AceType::MakeRefPtr<RotationRecognizer>(SINGLE_FINGER_NUMBER, ROTATION_GESTURE_ANGLE);
153 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anon6d6d5dda0202(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 154 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
155 return GestureJudgeResult::REJECT;
156 };
157 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
158 /**
159 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
160 * @tc.expected: step2. result equals CONTINUE.
161 */
162 rotationRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
163 rotationRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
164 rotationRecognizerPtr->inputEventType_ = InputEventType::AXIS;
165 auto result = rotationRecognizerPtr->TriggerGestureJudgeCallback();
166 EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
167 rotationRecognizerPtr->targetComponent_ = targetComponent;
168 EXPECT_EQ(rotationRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
169 rotationRecognizerPtr->inputEventType_ = InputEventType::TOUCH_PAD;
170 result = rotationRecognizerPtr->TriggerGestureJudgeCallback();
171 EXPECT_EQ(result, GestureJudgeResult::REJECT);
172 }
173
174 /**
175 * @tc.name: TransformTest001
176 * @tc.desc: Test Transform in Default Condition
177 */
178 HWTEST_F(GestureRecognizerTestNg, TransformTest001, TestSize.Level1)
179 {
180 /**
181 * @tc.steps: step1. create FrameNode.
182 */
183 RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
184 RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
185 RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
186 FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
187 FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
188
189 /**
190 * @tc.steps: step2. mock local matrix.
191 */
192 FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
193 FRAME_NODE_1->localMat_ = Matrix4::CreateIdentity();
194 FRAME_NODE_2->localMat_ = Matrix4::CreateIdentity();
195
196 /**
197 * @tc.steps: step2. call callback function.
198 */
199 PointF f1(1.0, 1.0);
200 NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
201 PointF f2(1.000000, 1.000000);
202 EXPECT_EQ(f1, f2);
203 }
204
205 /**
206 * @tc.name: TransformTest002
207 * @tc.desc: Test Transform with Matrix
208 */
209 HWTEST_F(GestureRecognizerTestNg, TransformTest002, TestSize.Level1)
210 {
211 /**
212 * @tc.steps: step1. create FrameNode.
213 */
214 RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
215 RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
216 RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
217 FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
218 FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
219
220 /**
221 * @tc.steps: step2. mock local matrix.
222 */
223 FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
224 FRAME_NODE_1->localMat_ = Matrix4::Invert(
225 Matrix4::CreateTranslate(100, 200, 0) * Matrix4::CreateRotate(90, 0, 0, 1) *
226 Matrix4::CreateScale(0.6, 0.8, 1));
227 FRAME_NODE_2->localMat_ = Matrix4::Invert(
228 Matrix4::CreateTranslate(400, 300, 0) * Matrix4::CreateRotate(30, 0, 0, 1) *
229 Matrix4::CreateScale(0.5, 0.5, 1));
230
231 /**
232 * @tc.steps: step3. call callback function.
233 */
234 PointF f1(1.0, 1.0);
235 NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
236 PointF f2(-1443.533813, 426.392731);
237 EXPECT_EQ(f1, f2);
238 }
239
240 /**
241 * @tc.name: TransformTest003
242 * @tc.desc: Test Transform with Matrix in Reverse Order
243 */
244 HWTEST_F(GestureRecognizerTestNg, TransformTest003, TestSize.Level1)
245 {
246 /**
247 * @tc.steps: step1. create FrameNode.
248 */
249 RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
250 RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
251 RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
252 FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
253 FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
254
255 /**
256 * @tc.steps: step2. mock local matrix.
257 */
258 FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
259 FRAME_NODE_2->localMat_ = Matrix4::Invert(
260 Matrix4::CreateTranslate(100, 200, 0) * Matrix4::CreateRotate(90, 0, 0, 1) *
261 Matrix4::CreateScale(0.6, 0.8, 1));
262 FRAME_NODE_1->localMat_ = Matrix4::Invert(
263 Matrix4::CreateTranslate(400, 300, 0) * Matrix4::CreateRotate(30, 0, 0, 1) *
264 Matrix4::CreateScale(0.5, 0.5, 1));
265
266 /**
267 * @tc.steps: step3. call callback function.
268 */
269 PointF f1(1.0, 1.0);
270 NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
271 PointF f2(-531.471924, 1362.610352);
272 EXPECT_EQ(f1, f2);
273 }
274
275 /**
276 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest001
277 * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
278 * @tc.type: FUNC
279 */
280 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
281 {
282 /**
283 * @tc.steps: step1. create and set Recognizer、TargetComponent.
284 */
285
286 RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
287 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
288 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anon6d6d5dda0302(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 289 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
290 return GestureJudgeResult::REJECT;};
291 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
292 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
293 PanDirection panDirection;
294 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
295 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
296 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
297 panRecognizerPtr->targetComponent_ = targetComponent;
298 panRecognizerPtr->targetComponent_->node_ = frameNode;
299 TouchEvent touchEvent;
300 touchEvent.tiltX.emplace(1.0f);
301 touchEvent.tiltY.emplace(1.0f);
302 panRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
303 panRecognizerPtr->direction_.type = PanDirection::ALL;
304 panRecognizerPtr->isFlushTouchEventsEnd_ = true;
305 panRecognizerPtr->averageDistance_ = Offset(0, -1);
306 panRecognizerPtr->distance_ = 0;
307 panRecognizerPtr->distanceMap_[SourceTool::UNKNOWN] = Dimension(0, DimensionUnit::PX);
308 panRecognizerPtr->currentFingers_ = 1;
309 panRecognizerPtr->fingers_ = 1;
310
311 /**
312 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
313 * @tc.steps: case1: gestureInfo_ is nullptr touchEvent
314 * @tc.expected: step2. result equals REJECT.
315 */
316 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
317 panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
318 EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::NONE);
319
320 /**
321 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
322 * @tc.steps: case2: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
323 * isDragUserReject_ = true touchEvent
324 * @tc.expected: step2. result equals REJECT.
325 */
326 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
327 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
328 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
329 guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
330 AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
331 guestureEventHub->dragEventActuator_->isDragUserReject_ = true;
332 panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
333 EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::REJECT);
334
335 /**
336 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
337 * @tc.steps: case3: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
338 * isDragUserReject_ = false touchEvent
339 * @tc.expected: step2. isDragUserReject_ = true.
340 */
341 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
342 guestureEventHub->dragEventActuator_->isDragUserReject_ = false;
343 panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
344 EXPECT_TRUE(guestureEventHub->dragEventActuator_->isDragUserReject_);
345 }
346
347 /**
348 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest002
349 * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
350 * @tc.type: FUNC
351 */
352 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest002, TestSize.Level1)
353 {
354 /**
355 * @tc.steps: step1. create and set Recognizer、TargetComponent.
356 */
357 RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
358 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
359 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anon6d6d5dda0402(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 360 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
361 return GestureJudgeResult::REJECT;};
362 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
363 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
364 PanDirection panDirection;
365 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
366 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
367 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
368 panRecognizerPtr->targetComponent_ = targetComponent;
369 panRecognizerPtr->targetComponent_->node_ = frameNode;
370 TouchEvent touchEvent;
371 touchEvent.tiltX.emplace(1.0f);
372 touchEvent.tiltY.emplace(1.0f);
373 AxisEvent axisEvent;
374 panRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
375 panRecognizerPtr->direction_.type = PanDirection::ALL;
376 panRecognizerPtr->isFlushTouchEventsEnd_ = true;
377 panRecognizerPtr->averageDistance_ = Offset(0, -1);
378 panRecognizerPtr->distance_ = 0;
379 panRecognizerPtr->distanceMap_[SourceTool::UNKNOWN] = Dimension(0, DimensionUnit::PX);
380 panRecognizerPtr->currentFingers_ = 1;
381 panRecognizerPtr->fingers_ = 1;
382
383 /**
384 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
385 * @tc.steps: case1: gestureInfo_ is nullptr axisEvent
386 * @tc.expected: step2. result equals REJECT.
387 */
388 panRecognizerPtr->inputEventType_ = InputEventType::AXIS;
389 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
390 panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
391 EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::NONE);
392
393 /**
394 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
395 * @tc.steps: case2: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
396 * isDragUserReject_ = true axisEvent
397 * @tc.expected: step2. result equals REJECT.
398 */
399 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
400 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
401 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
402 guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
403 AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
404 guestureEventHub->dragEventActuator_->isDragUserReject_ = true;
405 panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
406 EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::REJECT);
407
408 /**
409 * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
410 * @tc.steps: case3: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
411 * isDragUserReject_ = false axisEvent
412 * @tc.expected: step2. isDragUserReject_ = true.
413 */
414 panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
415 guestureEventHub->dragEventActuator_->isDragUserReject_ = false;
416 panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
417 EXPECT_TRUE(guestureEventHub->dragEventActuator_->isDragUserReject_);
418 }
419
420 class MockLongPressRecognizer : public LongPressRecognizer {
421 public:
MockLongPressRecognizer()422 MockLongPressRecognizer() : LongPressRecognizer(DURATION, FINGER_NUMBER) {}
423 MOCK_METHOD(void, HandleTouchUpEvent, (const TouchEvent&), (override));
424 MOCK_METHOD(void, HandleTouchCancelEvent, (const TouchEvent&), (override));
425 };
426
427 /**
428 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest003
429 * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
430 * @tc.type: FUNC
431 */
432 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest003, TestSize.Level1)
433 {
434 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(PINCH_GESTURE_DISTANCE, FINGER_NUMBER);
435 recognizerTest->fingersId_.insert(1);
436 recognizerTest->fingersId_.insert(2);
437 recognizerTest->fingersId_.insert(3);
438 recognizerTest->fingersId_.insert(4);
439 recognizerTest->fingersId_.insert(5);
440 recognizerTest->fingersId_.insert(6);
441 TouchEvent point;
442 point.type = TouchType::MOVE;
443 recognizerTest->HandleBridgeModeEvent(point);
444 point.type = TouchType::DOWN;
445 recognizerTest->HandleBridgeModeEvent(point);
446 point.sourceType = SourceType::MOUSE;
447 point.id = 4;
448 recognizerTest->HandleBridgeModeEvent(point);
449
450 point.type = TouchType::UP;
451 point.id = 2;
452 auto longPressRecoginzer = AceType::MakeRefPtr<MockLongPressRecognizer>();
453 longPressRecoginzer->fingersId_.clear();
454 longPressRecoginzer->fingersId_.insert(1);
455 longPressRecoginzer->fingersId_.insert(2);
456 longPressRecoginzer->fingersId_.insert(3);
457 longPressRecoginzer->fingersId_.insert(4);
458 EXPECT_CALL(*longPressRecoginzer, HandleTouchUpEvent(_)).WillRepeatedly(Return());
459 longPressRecoginzer->HandleBridgeModeEvent(point);
460 EXPECT_EQ(point.id, 2);
461 }
462
463 /**
464 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest004
465 * @tc.desc: Test PanPressRecognizer function: HandleBridgeModeEvent
466 * @tc.type: FUNC
467 */
468 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest004, TestSize.Level1)
469 {
470 auto longPressRecoginzer = AceType::MakeRefPtr<MockLongPressRecognizer>();
471 TouchEvent point;
472 point.type = TouchType::UP;
473 point.id = 8;
474 longPressRecoginzer->fingersId_.clear();
475 longPressRecoginzer->fingersId_.insert(1);
476 longPressRecoginzer->fingersId_.insert(2);
477 longPressRecoginzer->fingersId_.insert(3);
478 longPressRecoginzer->fingersId_.insert(4);
479 EXPECT_CALL(*longPressRecoginzer, HandleTouchUpEvent(_)).WillRepeatedly(Return());
480 longPressRecoginzer->HandleBridgeModeEvent(point);
481
482 point.type = TouchType::CANCEL;
483 longPressRecoginzer->fingersId_.clear();
484 longPressRecoginzer->fingersId_.insert(1);
485 longPressRecoginzer->fingersId_.insert(2);
486 longPressRecoginzer->fingersId_.insert(3);
487 longPressRecoginzer->fingersId_.insert(4);
488 point.id = 2;
489 EXPECT_CALL(*longPressRecoginzer, HandleTouchCancelEvent(_)).WillRepeatedly(Return());
490 longPressRecoginzer->HandleBridgeModeEvent(point);
491
492 point.type = TouchType::CANCEL;
493 longPressRecoginzer->fingersId_.clear();
494 longPressRecoginzer->fingersId_.insert(1);
495 longPressRecoginzer->fingersId_.insert(2);
496 longPressRecoginzer->fingersId_.insert(3);
497 longPressRecoginzer->fingersId_.insert(4);
498 point.id = 5;
499 EXPECT_CALL(*longPressRecoginzer, HandleTouchCancelEvent(_)).WillRepeatedly(Return());
500 longPressRecoginzer->HandleBridgeModeEvent(point);
501 point.type = TouchType::PULL_UP;
502 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(DURATION, FINGER_NUMBER);
503 recognizerTest->HandleBridgeModeEvent(point);
504 EXPECT_EQ(point.id, 5);
505 }
506
507 /**
508 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest005
509 * @tc.desc: Test PanPressRecognizer function: OnRejectBridgeObj
510 * @tc.type: FUNC
511 */
512 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest005, TestSize.Level1)
513 {
514 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(DURATION, FINGER_NUMBER);
515 recognizerTest->OnRejectBridgeObj();
516
517 WeakPtr<NGGestureRecognizer> bridgeObj = AceType::MakeRefPtr<MockNGGestureRecognizer>();
518 recognizerTest->bridgeObjList_.push_back(bridgeObj);
519 recognizerTest->OnRejectBridgeObj();
520 EXPECT_NE(recognizerTest->Dump(), nullptr);
521 }
522
523 /**
524 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest006
525 * @tc.desc: Test PanPressRecognizer function: HandleBridgeModeEvent
526 * @tc.type: FUNC
527 */
528 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest006, TestSize.Level1)
529 {
530 AxisEvent event;
531 auto longPressRecoginzer = AceType::MakeRefPtr<MockLongPressRecognizer>();
532 event.action = AxisAction::NONE;
533 longPressRecoginzer->HandleBridgeModeEvent(event);
534 event.action = AxisAction::BEGIN;
535 longPressRecoginzer->HandleBridgeModeEvent(event);
536 event.action = AxisAction::UPDATE;
537 longPressRecoginzer->HandleBridgeModeEvent(event);
538 event.action = AxisAction::END;
539 longPressRecoginzer->HandleBridgeModeEvent(event);
540 EXPECT_EQ(event.action, AxisAction::END);
541 }
542
543 /**
544 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest007
545 * @tc.desc: Test Dump
546 * @tc.type: FUNC
547 */
548 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest007, TestSize.Level1)
549 {
550 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(DURATION, FINGER_NUMBER);
551 EXPECT_NE(recognizerTest->Dump(), nullptr);
552 }
553
554 /**
555 * @tc.name: PanPressRecognizerHandleTouchMoveEventTest008
556 * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
557 * @tc.type: FUNC
558 */
559 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest008, TestSize.Level1)
560 {
561 auto recognizerTest = AceType::MakeRefPtr<LongPressRecognizer>(DURATION, FINGER_NUMBER);
562 RefPtr<NGGestureRecognizer> targetPtr1 = nullptr;
563 RefPtr<NGGestureRecognizer> targetPtr2 = nullptr;
564 std::list<RefPtr<NGGestureRecognizer>> responseLinkResult;
565 responseLinkResult.push_back(targetPtr1);
566 responseLinkResult.push_back(targetPtr2);
567 recognizerTest->SetResponseLinkRecognizers(responseLinkResult);
568 EXPECT_NE(recognizerTest->Dump(), nullptr);
569 }
570
571 /**
572 * @tc.name: GestureRecognizerHandleEvent001
573 * @tc.desc: Test GestureRecognizer function: AboutToAddCurrentFingers AboutToMinusCurrentFingers
574 * @tc.type: FUNC
575 */
576 HWTEST_F(GestureRecognizerTestNg, GestureRecognizerHandleEvent001, TestSize.Level1)
577 {
578 /**
579 * @tc.steps: step1. create ExclusiveRecognizer.
580 */
581 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
582 TouchEvent touchEvent;
583 bool result = false;
584
585 /**
586 * @tc.steps: step3. set currentFinger = 0, add touchEvent to gestureRecognizer.
587 * @tc.steps: case1: touchPoints is in recognizer region.
588 * @tc.expected: step3. func success, clickRecognizer currentFingers add.
589 */
590 clickRecognizerPtr->currentFingers_ = 0;
591 result = clickRecognizerPtr->AboutToAddCurrentFingers(touchEvent);
592 EXPECT_EQ(result, true);
593 EXPECT_EQ(clickRecognizerPtr->currentFingers_, 1);
594
595 /**
596 * @tc.steps: step3. set currentFinger = 1, delete touchEvent to gestureRecognizer.
597 * @tc.steps: case2: fingersId not find touchEvent id.
598 * @tc.expected: step3. func fail.
599 */
600 clickRecognizerPtr->currentFingers_ = 1;
601 result = clickRecognizerPtr->AboutToMinusCurrentFingers(0);
602 EXPECT_EQ(result, false);
603 EXPECT_EQ(clickRecognizerPtr->currentFingers_, 1);
604
605 /**
606 * @tc.steps: step3. set currentFinger = 1, delete touchEvent to gestureRecognizer.
607 * @tc.steps: case3: fingersId find touchEvent id.
608 * @tc.expected: step3. func success, currentFingers delete.
609 */
610 clickRecognizerPtr->currentFingers_ = 1;
611 clickRecognizerPtr->fingersId_.insert(0);
612 result = clickRecognizerPtr->AboutToMinusCurrentFingers(0);
613 EXPECT_EQ(result, true);
614 }
615
616 /**
617 * @tc.name: HandlePanGestureAccept_001
618 * @tc.desc: Test GestureRecognizer function: HandlePanGestureAccept
619 * @tc.type: FUNC
620 */
621
622 HWTEST_F(GestureRecognizerTestNg, HandlePanGestureAccept_001, TestSize.Level1)
623 {
624 PanDirection direction;
625 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(SINGLE_FINGER_NUMBER, direction, 0);
626 ASSERT_NE(panRecognizerPtr, nullptr);
627 GestureEvent info;
__anon6d6d5dda0502(GestureEvent& info) 628 auto start = [](GestureEvent& info) {};
__anon6d6d5dda0602(GestureEvent& info) 629 auto end = [](GestureEvent& info) {};
630 panRecognizerPtr->SetOnActionStart(start);
631 panRecognizerPtr->SetOnActionEnd(end);
632 panRecognizerPtr->SetRecognizerType(GestureTypeName::PAN_GESTURE);
633 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onActionStart_, GestureCallbackType::START);
634 EXPECT_EQ(panRecognizerPtr->currentCallbackState_, CurrentCallbackState::START);
635 }
636
637 /**
638 * @tc.name: HandlePanGestureAccept_002
639 * @tc.desc: Test GestureRecognizer function: HandlePanGestureAccept
640 * @tc.type: FUNC
641 */
642
643 HWTEST_F(GestureRecognizerTestNg, HandlePanGestureAccept_002, TestSize.Level1)
644 {
645 PanDirection direction;
646 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(SINGLE_FINGER_NUMBER, direction, 0);
647 ASSERT_NE(panRecognizerPtr, nullptr);
648 GestureEvent info;
__anon6d6d5dda0702(GestureEvent& info) 649 auto start = [](GestureEvent& info) {};
__anon6d6d5dda0802(GestureEvent& info) 650 auto end = [](GestureEvent& info) {};
651 panRecognizerPtr->SetOnActionStart(start);
652 panRecognizerPtr->SetOnActionEnd(end);
653 panRecognizerPtr->SetRecognizerType(GestureTypeName::PAN_GESTURE);
654 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onActionEnd_, GestureCallbackType::END);
655 EXPECT_EQ(panRecognizerPtr->currentCallbackState_, CurrentCallbackState::END);
656 }
657
658 /**
659 * @tc.name: TagGestureJudgeCallbackTest001
660 * @tc.desc: Test function: CreateTapGestureLocationEvent
661 * @tc.type: FUNC
662 */
663 HWTEST_F(GestureRecognizerTestNg, TagGestureJudgeCallbackTest001, TestSize.Level1)
664 {
665 /**
666 * @tc.steps: step1. create Recognizer、TargetComponent.
667 */
668 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
669
670 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
671
__anon6d6d5dda0902(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 672 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
673 gestureInfo->SetType(GestureTypeName::TAP_GESTURE);
674 return GestureJudgeResult::REJECT;};
675 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
676 /**
677 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
678 * @tc.expected: step2. result equals CONTINUE.
679 */
680 clickRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
681 clickRecognizerPtr->gestureInfo_->type_ = GestureTypeName::TAP_GESTURE;
682 auto result = clickRecognizerPtr->TriggerGestureJudgeCallback();
683 EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
684 }
685
686 /**
687 * @tc.name: LongPressGestureJudgeTest001
688 * @tc.desc: Test function: Create LongpresRecognizer TriggerGestureJudgeCallback.
689 * @tc.type: FUNC
690 */
691 HWTEST_F(GestureRecognizerTestNg, LongPressGestureJudgeTest001, TestSize.Level1)
692 {
693 /**
694 * @tc.steps: step1. create GestureEventHub, Recognizer, TargetComponent.
695 */
696 RefPtr<LongPressRecognizer> longPressRecognizerPtr = AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
697 FINGER_NUMBER, false);
698 ASSERT_NE(longPressRecognizerPtr, nullptr);
699 longPressRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
700 ASSERT_NE(longPressRecognizerPtr->gestureInfo_, nullptr);
701 longPressRecognizerPtr->gestureInfo_->type_ = GestureTypeName::PAN_GESTURE;
702 auto gestureJudgeNativeFunc = [](const RefPtr<GestureInfo>& gestureInfo,
__anon6d6d5dda0a02(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 703 const std::shared_ptr<BaseGestureEvent>& info) {
704 return GestureJudgeResult::CONTINUE;};
705 auto gestureJudgeNativeFuncForMenu = [](const RefPtr<GestureInfo>& gestureInfo,
__anon6d6d5dda0b02(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 706 const std::shared_ptr<BaseGestureEvent>& info) {
707 return GestureJudgeResult::REJECT;};
708 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
709 ASSERT_NE(frameNode, nullptr);
710 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
711 ASSERT_NE(gestureHub, nullptr);
712 gestureHub->SetOnGestureJudgeNativeBegin(gestureJudgeNativeFunc);
713 gestureHub->SetOnGestureJudgeNativeBeginForMenu(gestureJudgeNativeFuncForMenu);
714 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
715 ASSERT_NE(targetComponent, nullptr);
716 auto callbackNative = gestureHub->GetOnGestureJudgeNativeBeginCallback();
717 targetComponent->SetOnGestureJudgeNativeBegin(std::move(callbackNative));
718
719 /**
720 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
721 * @tc.expected: step2. result equals REJECT.
722 */
723 longPressRecognizerPtr->SetTargetComponent(targetComponent);
724 auto result = longPressRecognizerPtr->TriggerGestureJudgeCallback();
725 EXPECT_EQ(result, GestureJudgeResult::REJECT);
726 }
727
728 /**
729 * @tc.name: HandleGestureAcceptTest001
730 * @tc.desc: Test function: HandleGestureAccept for PanRecognizer
731 * @tc.type: FUNC
732 */
733 HWTEST_F(GestureRecognizerTestNg, HandleGestureAcceptTest001, TestSize.Level1)
734 {
735 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
736 ASSERT_NE(frameNode, nullptr);
737 PanDirection direction;
738 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(SINGLE_FINGER_NUMBER, direction, 0);
739 ASSERT_NE(panRecognizerPtr, nullptr);
740 panRecognizerPtr->AttachFrameNode(frameNode);
741 GestureEvent info;
__anon6d6d5dda0c02(GestureEvent& info) 742 auto start = [](GestureEvent& info) {};
__anon6d6d5dda0d02(GestureEvent& info) 743 auto action = [](GestureEvent& info) {};
__anon6d6d5dda0e02(GestureEvent& info) 744 auto end = [](GestureEvent& info) {};
745 panRecognizerPtr->SetOnActionStart(start);
746 panRecognizerPtr->SetOnAction(action);
747 panRecognizerPtr->SetOnActionEnd(end);
748 panRecognizerPtr->SetRecognizerType(GestureTypeName::PAN_GESTURE);
749 auto startCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
750 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda0f02(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 751 GestureActionPhase phase) {
752 EXPECT_EQ(phase, GestureActionPhase::WILL_START);
753 EXPECT_EQ(gestureListenerType, GestureListenerType::PAN);
754 };
755 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(startCallback);
756 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onActionStart_, GestureCallbackType::START);
757 auto actionCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
758 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1002(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 759 GestureActionPhase phase) {
760 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
761 EXPECT_EQ(gestureListenerType, GestureListenerType::PAN);
762 };
763 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(actionCallback);
764 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onAction_, GestureCallbackType::ACTION);
765 auto endCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
766 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1102(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 767 GestureActionPhase phase) {
768 EXPECT_EQ(phase, GestureActionPhase::WILL_END);
769 EXPECT_EQ(gestureListenerType, GestureListenerType::PAN);
770 };
771 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallback);
772 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onActionEnd_, GestureCallbackType::END);
773 auto endCallbackError = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
774 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1202(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 775 GestureActionPhase phase) {
776 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
777 EXPECT_EQ(gestureListenerType, GestureListenerType::PAN);
778 };
779 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallbackError);
780 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onActionEnd_, GestureCallbackType::UPDATE);
781 }
782
783 /**
784 * @tc.name: HandleGestureAcceptTest002
785 * @tc.desc: Test function: HandleGestureAccept for ClickRecognizer
786 * @tc.type: FUNC
787 */
788 HWTEST_F(GestureRecognizerTestNg, HandleGestureAcceptTest002, TestSize.Level1)
789 {
790 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
791 ASSERT_NE(frameNode, nullptr);
792 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
793 ASSERT_NE(clickRecognizerPtr, nullptr);
794 clickRecognizerPtr->AttachFrameNode(frameNode);
795 GestureEvent info;
__anon6d6d5dda1302(GestureEvent& info) 796 auto start = [](GestureEvent& info) {};
__anon6d6d5dda1402(GestureEvent& info) 797 auto action = [](GestureEvent& info) {};
__anon6d6d5dda1502(GestureEvent& info) 798 auto end = [](GestureEvent& info) {};
799 clickRecognizerPtr->SetOnActionStart(start);
800 clickRecognizerPtr->SetOnAction(action);
801 clickRecognizerPtr->SetOnActionEnd(end);
802 clickRecognizerPtr->SetRecognizerType(GestureTypeName::TAP_GESTURE);
803
804 auto startCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
805 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1602(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 806 GestureActionPhase phase) {
807 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
808 EXPECT_EQ(gestureListenerType, GestureListenerType::TAP);
809 };
810 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(startCallback);
811 clickRecognizerPtr->SendCallbackMsg(clickRecognizerPtr->onActionStart_, GestureCallbackType::START);
812
813 auto actionCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
814 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1702(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 815 GestureActionPhase phase) {
816 EXPECT_EQ(phase, GestureActionPhase::WILL_START);
817 EXPECT_EQ(gestureListenerType, GestureListenerType::TAP);
818 };
819 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(actionCallback);
820 clickRecognizerPtr->SendCallbackMsg(clickRecognizerPtr->onAction_, GestureCallbackType::ACTION);
821
822 auto endCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
823 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1802(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 824 GestureActionPhase phase) {
825 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
826 EXPECT_EQ(gestureListenerType, GestureListenerType::TAP);
827 };
828 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallback);
829 clickRecognizerPtr->SendCallbackMsg(clickRecognizerPtr->onActionEnd_, GestureCallbackType::END);
830 clickRecognizerPtr->SetRecognizerType(GestureTypeName::CLICK);
831 clickRecognizerPtr->SendCallbackMsg(clickRecognizerPtr->onActionEnd_, GestureCallbackType::END);
832 }
833
834 /**
835 * @tc.name: HandleGestureAcceptTest003
836 * @tc.desc: Test function: HandleGestureAccept for LongPressRecognizer
837 * @tc.type: FUNC
838 */
839 HWTEST_F(GestureRecognizerTestNg, HandleGestureAcceptTest003, TestSize.Level1)
840 {
841 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
842 ASSERT_NE(frameNode, nullptr);
843 RefPtr<LongPressRecognizer> longPressRecognizerPtr = AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
844 FINGER_NUMBER, false);
845 ASSERT_NE(longPressRecognizerPtr, nullptr);
846 longPressRecognizerPtr->AttachFrameNode(frameNode);
847 GestureEvent info;
__anon6d6d5dda1902(GestureEvent& info) 848 auto start = [](GestureEvent& info) {};
__anon6d6d5dda1a02(GestureEvent& info) 849 auto action = [](GestureEvent& info) {};
__anon6d6d5dda1b02(GestureEvent& info) 850 auto end = [](GestureEvent& info) {};
851 longPressRecognizerPtr->SetOnActionStart(start);
852 longPressRecognizerPtr->SetOnAction(action);
853 longPressRecognizerPtr->SetOnActionEnd(end);
854 longPressRecognizerPtr->SetRecognizerType(GestureTypeName::LONG_PRESS_GESTURE);
855
856 auto startCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
857 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1c02(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 858 GestureActionPhase phase) {
859 EXPECT_EQ(phase, GestureActionPhase::WILL_START);
860 EXPECT_EQ(gestureListenerType, GestureListenerType::LONG_PRESS);
861 };
862 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(startCallback);
863 longPressRecognizerPtr->SendCallbackMsg(longPressRecognizerPtr->onActionStart_, false, GestureCallbackType::START);
864
865 auto actionCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
866 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1d02(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 867 GestureActionPhase phase) {
868 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
869 EXPECT_EQ(gestureListenerType, GestureListenerType::LONG_PRESS);
870 };
871 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(actionCallback);
872 longPressRecognizerPtr->SendCallbackMsg(longPressRecognizerPtr->onAction_, false, GestureCallbackType::ACTION);
873
874 auto endCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
875 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda1e02(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 876 GestureActionPhase phase) {
877 EXPECT_EQ(phase, GestureActionPhase::WILL_END);
878 EXPECT_EQ(gestureListenerType, GestureListenerType::LONG_PRESS);
879 };
880 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallback);
881 longPressRecognizerPtr->SendCallbackMsg(longPressRecognizerPtr->onActionEnd_, false, GestureCallbackType::END);
882 }
883
884 /**
885 * @tc.name: HandleGestureAcceptTest004
886 * @tc.desc: Test function: HandleGestureAccept for PinchRecognizer
887 * @tc.type: FUNC
888 */
889 HWTEST_F(GestureRecognizerTestNg, HandleGestureAcceptTest004, TestSize.Level1)
890 {
891 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
892 ASSERT_NE(frameNode, nullptr);
893 RefPtr<PinchRecognizer> pinchRecognizerPtr = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER,
894 PINCH_GESTURE_DISTANCE);
895 ASSERT_NE(pinchRecognizerPtr, nullptr);
896 pinchRecognizerPtr->AttachFrameNode(frameNode);
897 GestureEvent info;
__anon6d6d5dda1f02(GestureEvent& info) 898 auto start = [](GestureEvent& info) {};
__anon6d6d5dda2002(GestureEvent& info) 899 auto action = [](GestureEvent& info) {};
__anon6d6d5dda2102(GestureEvent& info) 900 auto end = [](GestureEvent& info) {};
901 pinchRecognizerPtr->SetOnActionStart(start);
902 pinchRecognizerPtr->SetOnAction(action);
903 pinchRecognizerPtr->SetOnActionEnd(end);
904 pinchRecognizerPtr->SetRecognizerType(GestureTypeName::PINCH_GESTURE);
905
906 auto startCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
907 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda2202(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 908 GestureActionPhase phase) {
909 EXPECT_EQ(phase, GestureActionPhase::WILL_START);
910 EXPECT_EQ(gestureListenerType, GestureListenerType::PINCH);
911 };
912 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(startCallback);
913 pinchRecognizerPtr->SendCallbackMsg(pinchRecognizerPtr->onActionStart_, GestureCallbackType::START);
914
915 auto actionCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
916 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda2302(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 917 GestureActionPhase phase) {
918 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
919 EXPECT_EQ(gestureListenerType, GestureListenerType::PINCH);
920 };
921 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(actionCallback);
922 pinchRecognizerPtr->SendCallbackMsg(pinchRecognizerPtr->onAction_, GestureCallbackType::ACTION);
923
924 auto endCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
925 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda2402(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 926 GestureActionPhase phase) {
927 EXPECT_EQ(phase, GestureActionPhase::WILL_END);
928 EXPECT_EQ(gestureListenerType, GestureListenerType::PINCH);
929 };
930 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallback);
931 pinchRecognizerPtr->SendCallbackMsg(pinchRecognizerPtr->onActionEnd_, GestureCallbackType::END);
932 }
933
934 /**
935 * @tc.name: HandleGestureAcceptTest005
936 * @tc.desc: Test function: HandleGestureAccept for RotationRecognizer
937 * @tc.type: FUNC
938 */
939 HWTEST_F(GestureRecognizerTestNg, HandleGestureAcceptTest005, TestSize.Level1)
940 {
941 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
942 ASSERT_NE(frameNode, nullptr);
943 RefPtr<RotationRecognizer> rotationRecognizerPtr =
944 AceType::MakeRefPtr<RotationRecognizer>(SINGLE_FINGER_NUMBER, ROTATION_GESTURE_ANGLE);
945 ASSERT_NE(rotationRecognizerPtr, nullptr);
946 rotationRecognizerPtr->AttachFrameNode(frameNode);
947 GestureEvent info;
__anon6d6d5dda2502(GestureEvent& info) 948 auto start = [](GestureEvent& info) {};
__anon6d6d5dda2602(GestureEvent& info) 949 auto action = [](GestureEvent& info) {};
__anon6d6d5dda2702(GestureEvent& info) 950 auto end = [](GestureEvent& info) {};
951 rotationRecognizerPtr->SetOnActionStart(start);
952 rotationRecognizerPtr->SetOnAction(action);
953 rotationRecognizerPtr->SetOnActionEnd(end);
954 rotationRecognizerPtr->SetRecognizerType(GestureTypeName::ROTATION_GESTURE);
955
956 auto startCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
957 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda2802(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 958 GestureActionPhase phase) {
959 EXPECT_EQ(phase, GestureActionPhase::WILL_START);
960 EXPECT_EQ(gestureListenerType, GestureListenerType::ROTATION);
961 };
962 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(startCallback);
963 rotationRecognizerPtr->SendCallbackMsg(rotationRecognizerPtr->onActionStart_, GestureCallbackType::START);
964
965 auto actionCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
966 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda2902(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 967 GestureActionPhase phase) {
968 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
969 EXPECT_EQ(gestureListenerType, GestureListenerType::ROTATION);
970 };
971 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(actionCallback);
972 rotationRecognizerPtr->SendCallbackMsg(rotationRecognizerPtr->onAction_, GestureCallbackType::ACTION);
973
974 auto endCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
975 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda2a02(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 976 GestureActionPhase phase) {
977 EXPECT_EQ(phase, GestureActionPhase::WILL_END);
978 EXPECT_EQ(gestureListenerType, GestureListenerType::ROTATION);
979 };
980 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallback);
981 rotationRecognizerPtr->SendCallbackMsg(rotationRecognizerPtr->onActionEnd_, GestureCallbackType::END);
982 }
983
984 /**
985 * @tc.name: HandleGestureAcceptTest006
986 * @tc.desc: Test function: HandleGestureAccept for SwipeRecognizer
987 * @tc.type: FUNC
988 */
989 HWTEST_F(GestureRecognizerTestNg, HandleGestureAcceptTest006, TestSize.Level1)
990 {
991 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
992 ASSERT_NE(frameNode, nullptr);
993 SwipeDirection swipeDirection;
994 RefPtr<SwipeRecognizer> swipeRecognizerPtr =
995 AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
996 ASSERT_NE(swipeRecognizerPtr, nullptr);
997 swipeRecognizerPtr->AttachFrameNode(frameNode);
998 GestureEvent info;
__anon6d6d5dda2b02(GestureEvent& info) 999 auto start = [](GestureEvent& info) {};
__anon6d6d5dda2c02(GestureEvent& info) 1000 auto action = [](GestureEvent& info) {};
__anon6d6d5dda2d02(GestureEvent& info) 1001 auto end = [](GestureEvent& info) {};
1002 swipeRecognizerPtr->SetOnActionStart(start);
1003 swipeRecognizerPtr->SetOnAction(action);
1004 swipeRecognizerPtr->SetOnActionEnd(end);
1005 swipeRecognizerPtr->SetRecognizerType(GestureTypeName::SWIPE_GESTURE);
1006
1007 auto startCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
1008 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda2e02(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 1009 GestureActionPhase phase) {
1010 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
1011 EXPECT_EQ(gestureListenerType, GestureListenerType::SWIPE);
1012 };
1013 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(startCallback);
1014 swipeRecognizerPtr->SendCallbackMsg(swipeRecognizerPtr->onActionStart_, GestureCallbackType::START);
1015
1016 auto actionCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
1017 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda2f02(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 1018 GestureActionPhase phase) {
1019 EXPECT_EQ(phase, GestureActionPhase::WILL_START);
1020 EXPECT_EQ(gestureListenerType, GestureListenerType::SWIPE);
1021 };
1022 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(actionCallback);
1023 swipeRecognizerPtr->SendCallbackMsg(swipeRecognizerPtr->onAction_, GestureCallbackType::ACTION);
1024
1025 auto endCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
1026 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda3002(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 1027 GestureActionPhase phase) {
1028 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
1029 EXPECT_EQ(gestureListenerType, GestureListenerType::SWIPE);
1030 };
1031 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallback);
1032 swipeRecognizerPtr->SendCallbackMsg(swipeRecognizerPtr->onActionEnd_, GestureCallbackType::END);
1033 }
1034
1035 /**
1036 * @tc.name: HandleGestureAcceptTest007
1037 * @tc.desc: Test function: HandleGestureAccept for PanRecognizer drag
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(GestureRecognizerTestNg, HandleGestureAcceptTest007, TestSize.Level1)
1041 {
1042 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
1043 ASSERT_NE(frameNode, nullptr);
1044 PanDirection direction;
1045 RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(SINGLE_FINGER_NUMBER, direction, 0);
1046 ASSERT_NE(panRecognizerPtr, nullptr);
1047 panRecognizerPtr->AttachFrameNode(frameNode);
1048 panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
1049 panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
1050 GestureEvent info;
__anon6d6d5dda3102(GestureEvent& info) 1051 auto start = [](GestureEvent& info) {};
__anon6d6d5dda3202(GestureEvent& info) 1052 auto action = [](GestureEvent& info) {};
__anon6d6d5dda3302(GestureEvent& info) 1053 auto end = [](GestureEvent& info) {};
1054 panRecognizerPtr->SetOnActionStart(start);
1055 panRecognizerPtr->SetOnAction(action);
1056 panRecognizerPtr->SetOnActionEnd(end);
1057 panRecognizerPtr->SetRecognizerType(GestureTypeName::PAN_GESTURE);
1058 auto startCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
1059 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda3402(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 1060 GestureActionPhase phase) {
1061 EXPECT_EQ(phase, GestureActionPhase::WILL_START);
1062 EXPECT_EQ(gestureListenerType, GestureListenerType::PAN);
1063 };
1064 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(startCallback);
1065 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onActionStart_, GestureCallbackType::START);
1066 auto actionCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
1067 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda3502(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 1068 GestureActionPhase phase) {
1069 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
1070 EXPECT_EQ(gestureListenerType, GestureListenerType::PAN);
1071 };
1072 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(actionCallback);
1073 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onAction_, GestureCallbackType::ACTION);
1074 auto endCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
1075 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda3602(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 1076 GestureActionPhase phase) {
1077 EXPECT_EQ(phase, GestureActionPhase::WILL_END);
1078 EXPECT_EQ(gestureListenerType, GestureListenerType::PAN);
1079 };
1080 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallback);
1081 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onActionEnd_, GestureCallbackType::END);
1082 auto endCallbackError = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
1083 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda3702(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 1084 GestureActionPhase phase) {
1085 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
1086 EXPECT_EQ(gestureListenerType, GestureListenerType::PAN);
1087 };
1088 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(endCallbackError);
1089 panRecognizerPtr->SendCallbackMsg(panRecognizerPtr->onActionEnd_, GestureCallbackType::UPDATE);
1090 }
1091
1092 /**
1093 * @tc.name: HandleGestureAcceptTest008
1094 * @tc.desc: Test function: HandleGestureAccept for ClickRecognizer
1095 * @tc.type: FUNC
1096 */
1097 HWTEST_F(GestureRecognizerTestNg, HandleGestureAcceptTest008, TestSize.Level1)
1098 {
1099 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
1100 ASSERT_NE(frameNode, nullptr);
1101 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(1, 1, false);
1102 ASSERT_NE(clickRecognizerPtr, nullptr);
1103 clickRecognizerPtr->AttachFrameNode(frameNode);
1104 GestureEvent info;
__anon6d6d5dda3802(GestureEvent& info) 1105 auto start = [](GestureEvent& info) {};
__anon6d6d5dda3902(GestureEvent& info) 1106 auto action = [](GestureEvent& info) {};
__anon6d6d5dda3a02(GestureEvent& info) 1107 auto end = [](GestureEvent& info) {};
1108 clickRecognizerPtr->SetOnActionStart(start);
1109 clickRecognizerPtr->SetOnAction(action);
1110 clickRecognizerPtr->SetOnActionEnd(end);
1111 clickRecognizerPtr->SetRecognizerType(GestureTypeName::CLICK);
1112
1113 auto startCallback = [](GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo,
1114 const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode,
__anon6d6d5dda3b02(GestureListenerType gestureListenerType, const GestureEvent& gestureEventInfo, const RefPtr<NGGestureRecognizer>& current, const RefPtr<FrameNode>& frameNode, GestureActionPhase phase) 1115 GestureActionPhase phase) {
1116 EXPECT_EQ(phase, GestureActionPhase::UNKNOWN);
1117 EXPECT_NE(gestureListenerType, GestureListenerType::TAP);
1118 };
1119 UIObserverHandler::GetInstance().SetHandleGestureHandleFunc(startCallback);
1120 clickRecognizerPtr->SendCallbackMsg(clickRecognizerPtr->onActionStart_, GestureCallbackType::START);
1121 }
1122 } // namespace OHOS::Ace::NG