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 "gtest/gtest.h"
17 #include "gesture_impl.cpp"
18 #include "native_gesture.h"
19 #include "native_interface.h"
20 #include "native_node.h"
21 #include "native_type.h"
22
23 #include "core/components_ng/gestures/recognizers/pan_recognizer.h"
24 #include "core/components_ng/gestures/recognizers/pinch_recognizer.h"
25 #include "core/components_ng/gestures/recognizers/rotation_recognizer.h"
26 #include "core/gestures/gesture_info.h"
27 #include "frameworks/core/components_ng/gestures/recognizers/click_recognizer.h"
28 #include "frameworks/core/components_ng/gestures/recognizers/long_press_recognizer.h"
29 #include "frameworks/core/components_ng/gestures/recognizers/pan_recognizer.h"
30 #include "frameworks/core/components_ng/gestures/recognizers/swipe_recognizer.h"
31 #include "frameworks/core/interfaces/arkoala/arkoala_api.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35 class NativeGestureTest : public testing::Test {
36 public:
SetUpTestCase()37 static void SetUpTestCase() {};
TearDownTestCase()38 static void TearDownTestCase() {};
39 };
40
41 /**
42 * @tc.name: NativeGestureTest001
43 * @tc.desc: Test createTapGesture function.
44 * @tc.type: FUNC
45 */
46 HWTEST_F(NativeGestureTest, NativeGestureTest001, TestSize.Level1)
47 {
48 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_1*>(
49 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_1"));
50 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
51 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
52 auto gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
53 auto group = gestureAPI->createGroupGesture(EXCLUSIVE_GROUP);
54 auto tapGesture = gestureAPI->createTapGesture(1, 1);
55 auto tapGesture1 = gestureAPI->createTapGesture(0, 11);
56 auto longPressGesture = gestureAPI->createLongPressGesture(1, true, 500);
57 auto panGesture = gestureAPI->createPanGesture(1, GESTURE_DIRECTION_DOWN, 5);
58 auto swipeGesture = gestureAPI->createSwipeGesture(1, 1, 5);
59 auto pinchGesture = gestureAPI->createPinchGesture(2, 20);
60 auto rotateGesture = gestureAPI->createRotationGesture(2, 90);
61 gestureAPI->addChildGesture(group, tapGesture);
62 gestureAPI->addChildGesture(group, tapGesture1);
63 gestureAPI->addChildGesture(group, longPressGesture);
__anon5b7370ad0102(ArkUI_GestureEvent *event, void *extraParam) 64 auto onActionCallBack = [](ArkUI_GestureEvent *event, void *extraParam) {};
65 gestureAPI->setGestureEventTarget(
66 longPressGesture, GESTURE_EVENT_ACTION_ACCEPT,
67 gestureNode, onActionCallBack);
__anon5b7370ad0202(ArkUI_GestureInterruptInfo* info) 68 auto onInterruptCallback = [](ArkUI_GestureInterruptInfo* info) -> ArkUI_GestureInterruptResult {
69 return GESTURE_INTERRUPT_RESULT_REJECT;
70 };
71 gestureAPI->setGestureInterrupterToNode(gestureNode, onInterruptCallback);
72 auto ret = gestureAPI->addGestureToNode(gestureNode, group, PRIORITY, NORMAL_GESTURE_MASK);
73 EXPECT_EQ(ret, 0);
74 gestureAPI->removeGestureFromNode(gestureNode, group);
75 gestureAPI->removeChildGesture(group, tapGesture);
76 gestureAPI->removeChildGesture(group, tapGesture1);
77 gestureAPI->removeChildGesture(group, longPressGesture);
78 gestureAPI->dispose(tapGesture);
79 gestureAPI->dispose(longPressGesture);
80 gestureAPI->dispose(panGesture);
81 gestureAPI->dispose(swipeGesture);
82 gestureAPI->dispose(pinchGesture);
83 gestureAPI->dispose(rotateGesture);
84 }
85
86 /**
87 * @tc.name: NativeGestureTest002
88 * @tc.desc: Test createTapGesture function.
89 * @tc.type: FUNC
90 */
91 HWTEST_F(NativeGestureTest, NativeGestureTest002, TestSize.Level1)
92 {
93 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_1*>(
94 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_1"));
95 auto pinchGesture = gestureAPI->createPinchGesture(2, 0.0f);
96 EXPECT_NE(pinchGesture, nullptr);
97 auto swipeGesture = gestureAPI->createSwipeGesture(1, 1, 0.0f);
98 EXPECT_NE(swipeGesture, nullptr);
99 auto panGesture = gestureAPI->createPanGesture(0, GESTURE_DIRECTION_DOWN, 5);
100 EXPECT_NE(panGesture, nullptr);
101 gestureAPI->dispose(pinchGesture);
102 gestureAPI->dispose(swipeGesture);
103 gestureAPI->dispose(panGesture);
104 EXPECT_NE(gestureAPI, nullptr);
105 }
106
107 /**
108 * @tc.name: NativeGestureTest003
109 * @tc.desc: Test the API2 setGestureInterrupterToNode function.
110 * @tc.type: FUNC
111 */
112 HWTEST_F(NativeGestureTest, NativeGestureTest003, TestSize.Level1)
113 {
114 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_2*>(
115 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_2"));
116 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
117 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
118 auto gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
119 auto group = gestureAPI->gestureApi1->createGroupGesture(EXCLUSIVE_GROUP);
120 auto tapGesture = gestureAPI->gestureApi1->createTapGesture(1, 1);
121 auto tapGesture1 = gestureAPI->gestureApi1->createTapGesture(0, 11);
122 auto longPressGesture = gestureAPI->gestureApi1->createLongPressGesture(1, true, 500);
123 auto panGesture = gestureAPI->gestureApi1->createPanGesture(1, GESTURE_DIRECTION_DOWN, 5);
124 auto swipeGesture = gestureAPI->gestureApi1->createSwipeGesture(1, 1, 5);
125 auto pinchGesture = gestureAPI->gestureApi1->createPinchGesture(2, 20);
126 auto rotateGesture = gestureAPI->gestureApi1->createRotationGesture(2, 90);
127 gestureAPI->gestureApi1->addChildGesture(group, tapGesture);
128 gestureAPI->gestureApi1->addChildGesture(group, tapGesture1);
129 gestureAPI->gestureApi1->addChildGesture(group, longPressGesture);
__anon5b7370ad0302(ArkUI_GestureEvent *event, void *extraParam) 130 auto onActionCallBack = [](ArkUI_GestureEvent *event, void *extraParam) {};
131 gestureAPI->gestureApi1->setGestureEventTarget(
132 longPressGesture, GESTURE_EVENT_ACTION_ACCEPT,
133 gestureNode, onActionCallBack);
__anon5b7370ad0402(ArkUI_GestureInterruptInfo* info) 134 auto onInterruptCallback = [](ArkUI_GestureInterruptInfo* info) -> ArkUI_GestureInterruptResult {
135 return GESTURE_INTERRUPT_RESULT_REJECT;
136 };
137 int userData = 1;
138 gestureAPI->setGestureInterrupterToNode(gestureNode, &userData, onInterruptCallback);
139 auto ret = gestureAPI->gestureApi1->addGestureToNode(gestureNode, group, PRIORITY, NORMAL_GESTURE_MASK);
140 EXPECT_EQ(ret, 0);
141 gestureAPI->gestureApi1->removeGestureFromNode(gestureNode, group);
142 gestureAPI->gestureApi1->removeChildGesture(group, tapGesture);
143 gestureAPI->gestureApi1->removeChildGesture(group, tapGesture1);
144 gestureAPI->gestureApi1->removeChildGesture(group, longPressGesture);
145 gestureAPI->gestureApi1->dispose(tapGesture);
146 gestureAPI->gestureApi1->dispose(longPressGesture);
147 gestureAPI->gestureApi1->dispose(panGesture);
148 gestureAPI->gestureApi1->dispose(swipeGesture);
149 gestureAPI->gestureApi1->dispose(pinchGesture);
150 gestureAPI->gestureApi1->dispose(rotateGesture);
151 }
152
153 /**
154 * @tc.name: NativeGestureTest004
155 * @tc.desc: Test the OH_ArkUI_GestureInterrupter_GetUserData function.
156 * @tc.type: FUNC
157 */
158 HWTEST_F(NativeGestureTest, NativeGestureTest004, TestSize.Level1)
159 {
160 auto info = new ArkUI_GestureInterruptInfo();
161 void* userDataVoidPtr = OH_ArkUI_GestureInterrupter_GetUserData(info);
162 int* userDataPtr = reinterpret_cast<int*>(userDataVoidPtr);
163 EXPECT_EQ(userDataPtr, nullptr);
164 delete info;
165 }
166
167 /**
168 * @tc.name: NativeGestureIssueTest001
169 * @tc.desc: Test the OH_ArkUI_GestureInterruptInfo_GetGestureEvent functions.
170 * @tc.type: FUNC
171 */
172 HWTEST_F(NativeGestureTest, NativeGestureIssueTest001, TestSize.Level1)
173 {
174 /**
175 * @tc.steps: step1.create ArkUI_GestureInterruptInfo, related function is called.
176 */
177 ArkUI_GestureInterruptInfo interruptInfo;
178 ArkUI_GestureEvent gestureEvent;
179 ArkUIGestureInterruptInfo interruptData;
180 auto* nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
181 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
182 auto* gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
183 interruptData.userData = reinterpret_cast<void*>(gestureNode);
184 interruptData.gestureEvent = &gestureEvent;
185 interruptInfo.interruptData = interruptData;
186
187 auto* event = OH_ArkUI_GestureInterruptInfo_GetGestureEvent(&interruptInfo);
188 /**
189 * @tc.expected: Return expected results.
190 */
191 EXPECT_NE(event, nullptr);
192 }
193
194 /**
195 * @tc.name: NativeNodeGestureRecognizer001
196 * @tc.desc: Test the OH_ArkUI_GetGestureParam_DirectMask function.
197 * @tc.type: FUNC
198 */
199 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer001, TestSize.Level1)
200 {
201 ArkUI_GestureRecognizer* recognizer = nullptr;
202 ArkUI_GestureDirectionMask directMask = 1;
203 auto ret = OH_ArkUI_GetGestureParam_DirectMask(recognizer, &directMask);
204 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
205 }
206
207 /**
208 * @tc.name: NativeNodeGestureRecognizer002
209 * @tc.desc: Test the OH_ArkUI_GetGestureParam_DirectMask function.
210 * @tc.type: FUNC
211 */
212 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer002, TestSize.Level1)
213 {
214 ArkUI_GestureRecognizer recognizer;
215 ArkUI_GestureDirectionMask* directMask = nullptr;
216 auto ret = OH_ArkUI_GetGestureParam_DirectMask(&recognizer, directMask);
217 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
218 }
219
220 /**
221 * @tc.name: NativeNodeGestureRecognizer003
222 * @tc.desc: Test the OH_ArkUI_GetGestureParam_DirectMask function.
223 * @tc.type: FUNC
224 */
225 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer003, TestSize.Level1)
226 {
227 ArkUI_GestureRecognizer recognizerNew = { 5, nullptr, nullptr, nullptr };
228 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
229 ArkUI_GestureDirectionMask directMaskNew = 1;
230 ArkUI_GestureDirectionMask* directMask = &directMaskNew;
231 OHOS::Ace::SwipeDirection direction = { OHOS::Ace::SwipeDirection::HORIZONTAL };
232 OHOS::Ace::NG::NGGestureRecognizer* gestureRecognizer = new OHOS::Ace::NG::SwipeRecognizer(1, direction, 100);
233 recognizer->recognizer = gestureRecognizer;
234 auto ret = OH_ArkUI_GetGestureParam_DirectMask(recognizer, directMask);
235 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
236 OHOS::Ace::PanDirection direction_another = { OHOS::Ace::PanDirection::LEFT };
237 OHOS::Ace::NG::NGGestureRecognizer* gestureRecognizer_another =
238 new OHOS::Ace::NG::PanRecognizer(1, direction_another, 5);
239 recognizer->recognizer = gestureRecognizer_another;
240 recognizer->type = 2;
241 ret = OH_ArkUI_GetGestureParam_DirectMask(recognizer, directMask);
242 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
243 recognizer->type = 3;
244 ret = OH_ArkUI_GetGestureParam_DirectMask(recognizer, directMask);
245 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
246 }
247
248 /**
249 * @tc.name: NativeNodeGestureRecognizer004
250 * @tc.desc: Test the OH_ArkUI_GetGestureParam_FingerCount function.
251 * @tc.type: FUNC
252 */
253 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer004, TestSize.Level1)
254 {
255 ArkUI_GestureRecognizer* recognizer = nullptr;
256 int finger = 2;
257 auto ret = OH_ArkUI_GetGestureParam_FingerCount(recognizer, &finger);
258 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
259 }
260
261 /**
262 * @tc.name: NativeNodeGestureRecognizer005
263 * @tc.desc: Test the OH_ArkUI_GetGestureParam_FingerCount function.
264 * @tc.type: FUNC
265 */
266 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer005, TestSize.Level1)
267 {
268 ArkUI_GestureRecognizer recognizer;
269 int* finger = nullptr;
270 auto ret = OH_ArkUI_GetGestureParam_FingerCount(&recognizer, finger);
271 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
272 }
273
274 /**
275 * @tc.name: NativeNodeGestureRecognizer006
276 * @tc.desc: Test the OH_ArkUI_GetGestureParam_FingerCount function.
277 * @tc.type: FUNC
278 */
279 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer006, TestSize.Level1)
280 {
281 ArkUI_GestureRecognizer recognizerNew = { 0, nullptr, nullptr, nullptr };
282 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
283 int fingerNew = 2;
284 int* finger = &fingerNew;
285 double distanceThreshold = std::numeric_limits<double>::infinity();
286 OHOS::Ace::NG::NGGestureRecognizer* tapRecognizer = new OHOS::Ace::NG::ClickRecognizer(1, 1, distanceThreshold);
287 recognizer->recognizer = tapRecognizer;
288 auto ret = OH_ArkUI_GetGestureParam_FingerCount(recognizer, finger);
289 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
290 recognizer->type = 1;
291 OHOS::Ace::NG::NGGestureRecognizer* longPressRecognizer =
292 new OHOS::Ace::NG::LongPressRecognizer(500, 1, true, false, false);
293 recognizer->recognizer = longPressRecognizer;
294 ret = OH_ArkUI_GetGestureParam_FingerCount(recognizer, finger);
295 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
296 recognizer->type = 3;
297 OHOS::Ace::NG::NGGestureRecognizer* pinchRecognizer = new OHOS::Ace::NG::PinchRecognizer(1, 5);
298 recognizer->recognizer = pinchRecognizer;
299 ret = OH_ArkUI_GetGestureParam_FingerCount(recognizer, finger);
300 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
301 recognizer->type = 4;
302 OHOS::Ace::NG::NGGestureRecognizer* rotationRecognizer = new OHOS::Ace::NG::RotationRecognizer(1, 1);
303 recognizer->recognizer = rotationRecognizer;
304 ret = OH_ArkUI_GetGestureParam_FingerCount(recognizer, finger);
305 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
306 recognizer->type = 5;
307 OHOS::Ace::SwipeDirection direction = { OHOS::Ace::SwipeDirection::HORIZONTAL };
308 OHOS::Ace::NG::NGGestureRecognizer* gestureRecognizer = new OHOS::Ace::NG::SwipeRecognizer(1, direction, 100);
309 recognizer->recognizer = gestureRecognizer;
310 ret = OH_ArkUI_GetGestureParam_FingerCount(recognizer, finger);
311 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
312 recognizer->type = 2;
313 OHOS::Ace::PanDirection direction_another = { OHOS::Ace::PanDirection::LEFT };
314 OHOS::Ace::NG::NGGestureRecognizer* gestureRecognizer_another =
315 new OHOS::Ace::NG::PanRecognizer(1, direction_another, 5);
316 recognizer->recognizer = gestureRecognizer_another;
317 ret = OH_ArkUI_GetGestureParam_FingerCount(recognizer, finger);
318 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
319 recognizer->type = -1;
320 ret = OH_ArkUI_GetGestureParam_FingerCount(recognizer, finger);
321 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
322 }
323
324 /**
325 * @tc.name: NativeNodeGestureRecognizer007
326 * @tc.desc: Test the OH_ArkUI_GetGestureParam_limitFingerCount function.
327 * @tc.type: FUNC
328 */
329 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer007, TestSize.Level1)
330 {
331 ArkUI_GestureRecognizer* recognizer = nullptr;
332 bool isLimited = false;
333 auto ret = OH_ArkUI_GetGestureParam_limitFingerCount(recognizer, &isLimited);
334 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
335 }
336
337 /**
338 * @tc.name: NativeNodeGestureRecognizer008
339 * @tc.desc: Test the OH_ArkUI_GetGestureParam_limitFingerCount function.
340 * @tc.type: FUNC
341 */
342 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer008, TestSize.Level1)
343 {
344 ArkUI_GestureRecognizer recognizer;
345 bool* isLimited = nullptr;
346 auto ret = OH_ArkUI_GetGestureParam_limitFingerCount(&recognizer, isLimited);
347 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
348 }
349
350 /**
351 * @tc.name: NativeNodeGestureRecognizer009
352 * @tc.desc: Test the OH_ArkUI_GetGestureParam_limitFingerCount function.
353 * @tc.type: FUNC
354 */
355 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer009, TestSize.Level1)
356 {
357 ArkUI_GestureRecognizer recognizerNew = { 0, nullptr, nullptr, nullptr };
358 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
359 bool isLimitedNew = false;
360 bool* isLimited = &isLimitedNew;
361 double distanceThreshold = std::numeric_limits<double>::infinity();
362 OHOS::Ace::NG::NGGestureRecognizer* tapRecognizer = new OHOS::Ace::NG::ClickRecognizer(1, 1, distanceThreshold);
363 recognizer->recognizer = tapRecognizer;
364 auto ret = OH_ArkUI_GetGestureParam_limitFingerCount(recognizer, isLimited);
365 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
366 recognizer->type = 1;
367 OHOS::Ace::NG::NGGestureRecognizer* longPressRecognizer =
368 new OHOS::Ace::NG::LongPressRecognizer(500, 1, true, false, false);
369 recognizer->recognizer = longPressRecognizer;
370 ret = OH_ArkUI_GetGestureParam_limitFingerCount(recognizer, isLimited);
371 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
372 recognizer->type = 3;
373 OHOS::Ace::NG::NGGestureRecognizer* pinchRecognizer = new OHOS::Ace::NG::PinchRecognizer(1, 5);
374 recognizer->recognizer = pinchRecognizer;
375 ret = OH_ArkUI_GetGestureParam_limitFingerCount(recognizer, isLimited);
376 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
377 recognizer->type = 4;
378 OHOS::Ace::NG::NGGestureRecognizer* rotationRecognizer = new OHOS::Ace::NG::RotationRecognizer(1, 1);
379 recognizer->recognizer = rotationRecognizer;
380 ret = OH_ArkUI_GetGestureParam_limitFingerCount(recognizer, isLimited);
381 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
382 recognizer->type = 5;
383 OHOS::Ace::SwipeDirection direction = { OHOS::Ace::SwipeDirection::HORIZONTAL };
384 OHOS::Ace::NG::NGGestureRecognizer* gestureRecognizer = new OHOS::Ace::NG::SwipeRecognizer(1, direction, 100);
385 recognizer->recognizer = gestureRecognizer;
386 ret = OH_ArkUI_GetGestureParam_limitFingerCount(recognizer, isLimited);
387 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
388 recognizer->type = 2;
389 OHOS::Ace::PanDirection direction_another = { OHOS::Ace::PanDirection::LEFT };
390 OHOS::Ace::NG::NGGestureRecognizer* gestureRecognizer_another =
391 new OHOS::Ace::NG::PanRecognizer(1, direction_another, 5);
392 recognizer->recognizer = gestureRecognizer_another;
393 ret = OH_ArkUI_GetGestureParam_limitFingerCount(recognizer, isLimited);
394 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
395 recognizer->type = -1;
396 ret = OH_ArkUI_GetGestureParam_limitFingerCount(recognizer, isLimited);
397 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
398 }
399
400 /**
401 * @tc.name: NativeNodeGestureRecognizer010
402 * @tc.desc: Test the OH_ArkUI_GetGestureParam_repeat function.
403 * @tc.type: FUNC
404 */
405 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer010, TestSize.Level1)
406 {
407 ArkUI_GestureRecognizer* recognizer = nullptr;
408 bool isRepeat = true;
409 auto ret = OH_ArkUI_GetGestureParam_repeat(recognizer, &isRepeat);
410 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
411 }
412
413 /**
414 * @tc.name: NativeNodeGestureRecognizer011
415 * @tc.desc: Test the OH_ArkUI_GetGestureParam_repeat function.
416 * @tc.type: FUNC
417 */
418 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer011, TestSize.Level1)
419 {
420 ArkUI_GestureRecognizer recognizer;
421 bool* isRepeat = nullptr;
422 auto ret = OH_ArkUI_GetGestureParam_repeat(&recognizer, isRepeat);
423 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
424 }
425
426 /**
427 * @tc.name: NativeNodeGestureRecognizer012
428 * @tc.desc: Test the OH_ArkUI_GetGestureParam_repeat function.
429 * @tc.type: FUNC
430 */
431 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer012, TestSize.Level1)
432 {
433 ArkUI_GestureRecognizer recognizerNew = { 1, nullptr, nullptr, nullptr };
434 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
435 bool isRepeatNew = true;
436 bool* isRepeat = &isRepeatNew;
437 OHOS::Ace::NG::NGGestureRecognizer* longPressRecognizer =
438 new OHOS::Ace::NG::LongPressRecognizer(500, 1, true, false, false);
439 recognizer->recognizer = longPressRecognizer;
440 auto ret = OH_ArkUI_GetGestureParam_repeat(recognizer, isRepeat);
441 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
442 recognizer->type = 2;
443 ret = OH_ArkUI_GetGestureParam_repeat(recognizer, isRepeat);
444 EXPECT_EQ(ret, ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED);
445 }
446
447 /**
448 * @tc.name: NativeNodeGestureRecognizer013
449 * @tc.desc: Test the OH_ArkUI_GetGestureParam_distance function.
450 * @tc.type: FUNC
451 */
452 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer013, TestSize.Level1)
453 {
454 ArkUI_GestureRecognizer* recognizer = nullptr;
455 double distance = 5;
456 auto ret = OH_ArkUI_GetGestureParam_distance(recognizer, &distance);
457 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
458 }
459
460 /**
461 * @tc.name: NativeNodeGestureRecognizer014
462 * @tc.desc: Test the OH_ArkUI_GetGestureParam_distance function.
463 * @tc.type: FUNC
464 */
465 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer014, TestSize.Level1)
466 {
467 ArkUI_GestureRecognizer recognizer;
468 double* distance = nullptr;
469 auto ret = OH_ArkUI_GetGestureParam_distance(&recognizer, distance);
470 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
471 }
472
473 /**
474 * @tc.name: NativeNodeGestureRecognizer015
475 * @tc.desc: Test the OH_ArkUI_GetGestureParam_distance function.
476 * @tc.type: FUNC
477 */
478 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer015, TestSize.Level1)
479 {
480 ArkUI_GestureRecognizer recognizerNew = { 3, nullptr, nullptr, nullptr };
481 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
482 double distanceNew = 5;
483 double* distance = &distanceNew;
484 OHOS::Ace::NG::NGGestureRecognizer* pinchRecognizer = new OHOS::Ace::NG::PinchRecognizer(1, 5);
485 recognizer->recognizer = pinchRecognizer;
486 auto ret = OH_ArkUI_GetGestureParam_distance(recognizer, distance);
487 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
488 recognizer->type = 2;
489 OHOS::Ace::PanDirection direction_another = { OHOS::Ace::PanDirection::LEFT };
490 OHOS::Ace::NG::NGGestureRecognizer* gestureRecognizer_another =
491 new OHOS::Ace::NG::PanRecognizer(1, direction_another, 5);
492 recognizer->recognizer = gestureRecognizer_another;
493 ret = OH_ArkUI_GetGestureParam_distance(recognizer, distance);
494 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
495 recognizer->type = 5;
496 ret = OH_ArkUI_GetGestureParam_distance(recognizer, distance);
497 EXPECT_EQ(ret, ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED);
498 }
499
500 /**
501 * @tc.name: NativeNodeGestureRecognizer016
502 * @tc.desc: Test the OH_ArkUI_GetGestureParam_speed function.
503 * @tc.type: FUNC
504 */
505 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer016, TestSize.Level1)
506 {
507 ArkUI_GestureRecognizer* recognizer = nullptr;
508 double speed = 100;
509 auto ret = OH_ArkUI_GetGestureParam_speed(recognizer, &speed);
510 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
511 }
512
513 /**
514 * @tc.name: NativeNodeGestureRecognizer017
515 * @tc.desc: Test the OH_ArkUI_GetGestureParam_speed function.
516 * @tc.type: FUNC
517 */
518 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer017, TestSize.Level1)
519 {
520 ArkUI_GestureRecognizer recognizer;
521 double* speed = nullptr;
522 auto ret = OH_ArkUI_GetGestureParam_speed(&recognizer, speed);
523 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
524 }
525
526 /**
527 * @tc.name: NativeNodeGestureRecognizer018
528 * @tc.desc: Test the OH_ArkUI_GetGestureParam_speed function.
529 * @tc.type: FUNC
530 */
531 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer018, TestSize.Level1)
532 {
533 ArkUI_GestureRecognizer recognizerNew = { 5, nullptr, nullptr, nullptr };
534 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
535 double speedNew = 100;
536 double* speed = &speedNew;
537 recognizer->type = 5;
538 OHOS::Ace::SwipeDirection direction = { OHOS::Ace::SwipeDirection::HORIZONTAL };
539 OHOS::Ace::NG::NGGestureRecognizer* gestureRecognizer = new OHOS::Ace::NG::SwipeRecognizer(1, direction, 100);
540 recognizer->recognizer = gestureRecognizer;
541 auto ret = OH_ArkUI_GetGestureParam_speed(recognizer, speed);
542 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
543 recognizer->type = 2;
544 ret = OH_ArkUI_GetGestureParam_speed(recognizer, speed);
545 EXPECT_EQ(ret, ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED);
546 }
547
548 /**
549 * @tc.name: NativeNodeGestureRecognizer019
550 * @tc.desc: Test the OH_ArkUI_GetGestureParam_duration function.
551 * @tc.type: FUNC
552 */
553 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer019, TestSize.Level1)
554 {
555 ArkUI_GestureRecognizer* recognizer = nullptr;
556 int duration = 500;
557 auto ret = OH_ArkUI_GetGestureParam_duration(recognizer, &duration);
558 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
559 }
560
561 /**
562 * @tc.name: NativeNodeGestureRecognizer020
563 * @tc.desc: Test the OH_ArkUI_GetGestureParam_duration function.
564 * @tc.type: FUNC
565 */
566 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer020, TestSize.Level1)
567 {
568 ArkUI_GestureRecognizer recognizer;
569 int* duration = nullptr;
570 auto ret = OH_ArkUI_GetGestureParam_duration(&recognizer, duration);
571 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
572 }
573
574 /**
575 * @tc.name: NativeNodeGestureRecognizer021
576 * @tc.desc: Test the OH_ArkUI_GetGestureParam_duration function.
577 * @tc.type: FUNC
578 */
579 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer021, TestSize.Level1)
580 {
581 ArkUI_GestureRecognizer recognizerNew = { 1, nullptr, nullptr, nullptr };
582 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
583 int durationNew = 500;
584 int* duration = &durationNew;
585 OHOS::Ace::NG::NGGestureRecognizer* longPressRecognizer =
586 new OHOS::Ace::NG::LongPressRecognizer(500, 1, true, false, false);
587 recognizer->recognizer = longPressRecognizer;
588 auto ret = OH_ArkUI_GetGestureParam_duration(recognizer, duration);
589 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
590 recognizer->type = 4;
591 ret = OH_ArkUI_GetGestureParam_duration(recognizer, duration);
592 EXPECT_EQ(ret, ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED);
593 }
594
595 /**
596 * @tc.name: NativeNodeGestureRecognizer022
597 * @tc.desc: Test the OH_ArkUI_GetGestureParam_angle function.
598 * @tc.type: FUNC
599 */
600 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer022, TestSize.Level1)
601 {
602 ArkUI_GestureRecognizer* recognizer = nullptr;
603 double angle = 1;
604 auto ret = OH_ArkUI_GetGestureParam_angle(recognizer, &angle);
605 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
606 }
607
608 /**
609 * @tc.name: NativeNodeGestureRecognizer023
610 * @tc.desc: Test the OH_ArkUI_GetGestureParam_angle function.
611 * @tc.type: FUNC
612 */
613 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer023, TestSize.Level1)
614 {
615 ArkUI_GestureRecognizer recognizer;
616 double* angle = nullptr;
617 auto ret = OH_ArkUI_GetGestureParam_angle(&recognizer, angle);
618 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
619 }
620
621 /**
622 * @tc.name: NativeNodeGestureRecognizer024
623 * @tc.desc: Test the OH_ArkUI_GetGestureParam_angle function.
624 * @tc.type: FUNC
625 */
626 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer024, TestSize.Level1)
627 {
628 ArkUI_GestureRecognizer recognizerNew = { 4, nullptr, nullptr, nullptr };
629 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
630 double angleNew = 1;
631 double* angle = &angleNew;
632 OHOS::Ace::NG::NGGestureRecognizer* rotationRecognizer = new OHOS::Ace::NG::RotationRecognizer(1, 1);
633 recognizer->recognizer = rotationRecognizer;
634 auto ret = OH_ArkUI_GetGestureParam_angle(recognizer, angle);
635 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
636 recognizer->type = 2;
637 ret = OH_ArkUI_GetGestureParam_angle(recognizer, angle);
638 EXPECT_EQ(ret, ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED);
639 }
640
641 /**
642 * @tc.name: NativeNodeGestureRecognizer025
643 * @tc.desc: Test the OH_ArkUI_GetGestureParam_distanceThreshold function.
644 * @tc.type: FUNC
645 */
646 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer025, TestSize.Level1)
647 {
648 ArkUI_GestureRecognizer* recognizer = nullptr;
649 double distanceThreshold = std::numeric_limits<double>::infinity();
650 auto ret = OH_ArkUI_GetGestureParam_distanceThreshold(recognizer, &distanceThreshold);
651 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
652 }
653
654 /**
655 * @tc.name: NativeNodeGestureRecognizer026
656 * @tc.desc: Test the OH_ArkUI_GetGestureParam_distanceThreshold function.
657 * @tc.type: FUNC
658 */
659 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer026, TestSize.Level1)
660 {
661 ArkUI_GestureRecognizer recognizer;
662 double* distanceThreshold = nullptr;
663 auto ret = OH_ArkUI_GetGestureParam_distanceThreshold(&recognizer, distanceThreshold);
664 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
665 }
666
667 /**
668 * @tc.name: NativeNodeGestureRecognizer027
669 * @tc.desc: Test the OH_ArkUI_GetGestureParam_distanceThreshold function.
670 * @tc.type: FUNC
671 */
672 HWTEST_F(NativeGestureTest, NativeNodeGestureRecognizer027, TestSize.Level1)
673 {
674 ArkUI_GestureRecognizer recognizerNew = { 0, nullptr, nullptr, nullptr };
675 ArkUI_GestureRecognizer* recognizer = &recognizerNew;
676 double distanceThresholdNew = std::numeric_limits<double>::infinity();
677 double* distanceThreshold = &distanceThresholdNew;
678 double distanceThresholdAnother = std::numeric_limits<double>::infinity();
679 OHOS::Ace::NG::NGGestureRecognizer* tapRecognizer =
680 new OHOS::Ace::NG::ClickRecognizer(1, 1, distanceThresholdAnother);
681 recognizer->recognizer = tapRecognizer;
682 auto ret = OH_ArkUI_GetGestureParam_distanceThreshold(recognizer, distanceThreshold);
683 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
684 recognizer->type = -1;
685 ret = OH_ArkUI_GetGestureParam_distanceThreshold(recognizer, distanceThreshold);
686 EXPECT_EQ(ret, ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED);
687 }
688
689 /**
690 * @tc.name: GestureImplTest001
691 * @tc.desc: Test the OH_ArkUI_GestureEvent_GetActionType function.
692 * @tc.type: FUNC
693 */
694 HWTEST_F(NativeGestureTest, GestureImplTest001, TestSize.Level1)
695 {
696 ArkUI_GestureEvent event;
697 event.eventData.subKind = ON_ACTION;
698 EXPECT_EQ(OH_ArkUI_GestureEvent_GetActionType(&event), GESTURE_EVENT_ACTION_ACCEPT);
699
700 event.eventData.subKind = ON_ACTION_START;
701 EXPECT_EQ(OH_ArkUI_GestureEvent_GetActionType(&event), GESTURE_EVENT_ACTION_ACCEPT);
702
703 event.eventData.subKind = ON_ACTION_UPDATE;
704 EXPECT_EQ(OH_ArkUI_GestureEvent_GetActionType(&event), GESTURE_EVENT_ACTION_UPDATE);
705
706 event.eventData.subKind = ON_ACTION_END;
707 EXPECT_EQ(OH_ArkUI_GestureEvent_GetActionType(&event), GESTURE_EVENT_ACTION_END);
708
709 event.eventData.subKind = ON_ACTION_CANCEL;
710 EXPECT_EQ(OH_ArkUI_GestureEvent_GetActionType(&event), GESTURE_EVENT_ACTION_CANCEL);
711
712 event.eventData.subKind = -1;
713 EXPECT_EQ(OH_ArkUI_GestureEvent_GetActionType(&event), GESTURE_EVENT_ACTION_ACCEPT);
714 }
715
716 /**
717 * @tc.name: GestureImplTest002
718 * @tc.desc: Test the OH_ArkUI_GestureEvent_GetRawInputEvent function.
719 * @tc.type: FUNC
720 */
721 HWTEST_F(NativeGestureTest, GestureImplTest002, TestSize.Level1)
722 {
723 auto* ret1 = OH_ArkUI_GestureEvent_GetRawInputEvent(nullptr);
724 EXPECT_EQ(ret1, nullptr);
725
726 ArkUI_GestureEvent event;
727 ArkUI_UIInputEvent inputEvent;
728 event.eventData.repeat = 10;
729 event.eventData.velocity = 10.0f;
730 event.eventData.velocityX = 11.0f;
731 event.eventData.velocityY = 12.0f;
732 event.eventData.x = 13.0f;
733 event.eventData.y = 14.0f;
734 event.eventData.angle = 15.0f;
735 event.eventData.speed = 16.0f;
736 event.eventData.scale = 17.0f;
737 event.eventData.pinchCenterX = 18.0f;
738 event.eventData.pinchCenterY = 19.0f;
739 event.eventData.rawPointerEvent = &inputEvent;
740 auto* ret2 = OH_ArkUI_GestureEvent_GetRawInputEvent(&event);
741 auto repeat = OH_ArkUI_LongPress_GetRepeatCount(&event);
742 auto velocity = OH_ArkUI_PanGesture_GetVelocity(&event);
743 auto velocityX = OH_ArkUI_PanGesture_GetVelocityX(&event);
744 auto velocityY = OH_ArkUI_PanGesture_GetVelocityY(&event);
745 auto x = OH_ArkUI_PanGesture_GetOffsetX(&event);
746 auto y = OH_ArkUI_PanGesture_GetOffsetY(&event);
747 auto swipeAngle = OH_ArkUI_SwipeGesture_GetAngle(&event);
748 auto speed = OH_ArkUI_SwipeGesture_GetVelocity(&event);
749 auto rotationAngle = OH_ArkUI_RotationGesture_GetAngle(&event);
750 auto scale = OH_ArkUI_PinchGesture_GetScale(&event);
751 auto pinchCenterX = OH_ArkUI_PinchGesture_GetCenterX(&event);
752 auto pinchCenterY = OH_ArkUI_PinchGesture_GetCenterY(&event);
753 EXPECT_NE(ret2, nullptr);
754 EXPECT_EQ(repeat, 10);
755 EXPECT_EQ(velocity, 10.0f);
756 EXPECT_EQ(velocityX, 11.0f);
757 EXPECT_EQ(velocityY, 12.0f);
758 EXPECT_EQ(x, 13.0f);
759 EXPECT_EQ(y, 14.0f);
760 EXPECT_EQ(swipeAngle, 15.0f);
761 EXPECT_EQ(speed, 16.0f);
762 EXPECT_EQ(rotationAngle, 15.0f);
763 EXPECT_EQ(scale, 17.0f);
764 EXPECT_EQ(pinchCenterX, 18.0f);
765 EXPECT_EQ(pinchCenterY, 19.0f);
766 }
767
768 /**
769 * @tc.name: GestureImplTest003
770 * @tc.desc: Test the OH_ArkUI_GestureEvent_GetNode function.
771 * @tc.type: FUNC
772 */
773 HWTEST_F(NativeGestureTest, GestureImplTest003, TestSize.Level1)
774 {
775 auto* ret1 = OH_ArkUI_GestureEvent_GetNode(nullptr);
776 EXPECT_EQ(ret1, nullptr);
777
778 ArkUI_GestureEvent event;
779 ArkUI_NodeHandle node;
780 event.eventData.repeat = 10;
781 event.attachNode = &node;
782 auto* ret2 = OH_ArkUI_GestureEvent_GetNode(&event);
783 EXPECT_NE(ret2, nullptr);
784 }
785
786 /**
787 * @tc.name: GestureImplTest004
788 * @tc.desc: Test the OH_ArkUI_GestureInterruptInfo_GetSystemFlag function.
789 * @tc.type: FUNC
790 */
791 HWTEST_F(NativeGestureTest, GestureImplTest004, TestSize.Level1)
792 {
793 ArkUI_GestureInterruptInfo interruptInfo;
794 interruptInfo.interruptData.isSystemGesture = true;
795 auto result = OH_ArkUI_GestureInterruptInfo_GetSystemFlag(&interruptInfo);
796 EXPECT_TRUE(result);
797
798 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
799 interruptInfo.interruptData.userData = recognizer;
800 auto* re1 = OH_ArkUI_GestureInterruptInfo_GetRecognizer(&interruptInfo);
801 EXPECT_NE(re1, nullptr);
802 }
803
804 /**
805 * @tc.name: GestureImplTest005
806 * @tc.desc: Test the OH_ArkUI_GestureInterruptInfo_GetGestureEvent function.
807 * @tc.type: FUNC
808 */
809 HWTEST_F(NativeGestureTest, GestureImplTest005, TestSize.Level1)
810 {
811 auto* ret1 = OH_ArkUI_GestureInterruptInfo_GetGestureEvent(nullptr);
812 EXPECT_EQ(ret1, nullptr);
813
814 ArkUI_GestureInterruptInfo interruptInfo;
815 interruptInfo.interruptData.gestureEvent = nullptr;
816 auto* re2 = OH_ArkUI_GestureInterruptInfo_GetGestureEvent(&interruptInfo);
817 EXPECT_EQ(re2, nullptr);
818
819 ArkUI_GestureEvent event;
820 event.eventData.repeat = 10;
821 interruptInfo.interruptData.gestureEvent = &event;
822 interruptInfo.interruptData.inputEvent = nullptr;
823 ArkUI_GestureEvent* gestureEvent = reinterpret_cast<ArkUI_GestureEvent*>(interruptInfo.interruptData.gestureEvent);
824 EXPECT_EQ(gestureEvent->eventData.rawPointerEvent, nullptr);
825
826 interruptInfo.interruptData.userData = nullptr;
827 auto* re3 = OH_ArkUI_GestureInterruptInfo_GetGestureEvent(&interruptInfo);
828 EXPECT_EQ(re3, nullptr);
829
830 auto* nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
831 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
832 auto* gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
833 interruptInfo.interruptData.userData = reinterpret_cast<void*>(gestureNode);
834 auto* re4 = OH_ArkUI_GestureInterruptInfo_GetGestureEvent(&interruptInfo);
835 EXPECT_NE(re4, nullptr);
836 }
837
838 /**
839 * @tc.name: GestureImplTest006
840 * @tc.desc: Test the OH_ArkUI_GestureInterruptInfo_GetSystemRecognizerType function.
841 * @tc.type: FUNC
842 */
843 HWTEST_F(NativeGestureTest, GestureImplTest006, TestSize.Level1)
844 {
845 ArkUI_GestureInterruptInfo interruptInfo;
846 interruptInfo.interruptData.isSystemGesture = true;
847 interruptInfo.interruptData.systemRecognizerType = 10;
848 auto result = OH_ArkUI_GestureInterruptInfo_GetSystemRecognizerType(&interruptInfo);
849 EXPECT_EQ(result, 10);
850
851 interruptInfo.interruptData.isSystemGesture = false;
852 result = OH_ArkUI_GestureInterruptInfo_GetSystemRecognizerType(&interruptInfo);
853 EXPECT_EQ(result, -1);
854 }
855
856 /**
857 * @tc.name: GestureImplTest007
858 * @tc.desc: Test the OH_ArkUI_GestureInterruptInfo_GetTouchRecognizers function.
859 * @tc.type: FUNC
860 */
861 HWTEST_F(NativeGestureTest, GestureImplTest007, TestSize.Level1)
862 {
863 ArkUI_GestureInterruptInfo interruptInfo;
864 ArkUI_TouchRecognizerHandleArray recognizers;
865 interruptInfo.interruptData.touchRecognizerCnt = 10;
866
867 int32_t size;
868 auto ret1 = OH_ArkUI_GestureInterruptInfo_GetTouchRecognizers(nullptr, &recognizers, &size);
869 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
870 auto ret2 = OH_ArkUI_GestureInterruptInfo_GetTouchRecognizers(&interruptInfo, nullptr, &size);
871 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
872 auto ret3 = OH_ArkUI_GestureInterruptInfo_GetTouchRecognizers(&interruptInfo, &recognizers, nullptr);
873 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID);
874 auto ret4 = OH_ArkUI_GestureInterruptInfo_GetTouchRecognizers(&interruptInfo, &recognizers, &size);
875 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_NO_ERROR);
876 EXPECT_EQ(size, 10);
877 }
878
879 /**
880 * @tc.name: GestureImplTest008
881 * @tc.desc: Test the OH_ArkUI_TouchRecognizer_GetNodeHandle function.
882 * @tc.type: FUNC
883 */
884 HWTEST_F(NativeGestureTest, GestureImplTest008, TestSize.Level1)
885 {
886 auto ret1 = OH_ArkUI_TouchRecognizer_GetNodeHandle(nullptr);
887 EXPECT_EQ(ret1, nullptr);
888 }
889
890 /**
891 * @tc.name: GestureImplTest009
892 * @tc.desc: Test the OH_ArkUI_TouchRecognizer_CancelTouch function.
893 * @tc.type: FUNC
894 */
895 HWTEST_F(NativeGestureTest, GestureImplTest009, TestSize.Level1)
896 {
897 ArkUI_GestureInterruptInfo interruptInfo;
898 interruptInfo.interruptData.touchRecognizerCnt = 10;
899 auto ret1 = OH_ArkUI_TouchRecognizer_CancelTouch(nullptr, &interruptInfo);
900 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
901 }
902
903 /**
904 * @tc.name: GestureImplTest0010
905 * @tc.desc: Test the OH_ArkUI_GetResponseRecognizersFromInterruptInfo function.
906 * @tc.type: FUNC
907 */
908 HWTEST_F(NativeGestureTest, GestureImplTest0010, TestSize.Level1)
909 {
910 ArkUI_GestureRecognizerHandleArray recognizers;
911 ArkUI_GestureInterruptInfo interruptInfo;
912 interruptInfo.interruptData.count = 10;
913 int32_t count = 10;
914 auto ret1 = OH_ArkUI_GetResponseRecognizersFromInterruptInfo(&interruptInfo, nullptr, &count);
915 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
916 auto ret2 = OH_ArkUI_GetResponseRecognizersFromInterruptInfo(&interruptInfo, &recognizers, nullptr);
917 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
918 auto ret3 = OH_ArkUI_GetResponseRecognizersFromInterruptInfo(&interruptInfo, &recognizers, &count);
919 EXPECT_EQ(ret3, 0);
920 EXPECT_EQ(count, 10);
921 }
922
923 /**
924 * @tc.name: GestureImplTest0011
925 * @tc.desc: Test the OH_ArkUI_SetGestureRecognizerEnabled function.
926 * @tc.type: FUNC
927 */
928 HWTEST_F(NativeGestureTest, GestureImplTest0011, TestSize.Level1)
929 {
930 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
931 auto ret1 = OH_ArkUI_SetGestureRecognizerEnabled(nullptr, true);
932 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
933 auto ret2 = OH_ArkUI_SetGestureRecognizerEnabled(recognizer, true);
934 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
935
936 auto ret3 = OH_ArkUI_GetGestureRecognizerEnabled(nullptr);
937 EXPECT_EQ(ret3, false);
938 auto ret4 = OH_ArkUI_GetGestureRecognizerEnabled(recognizer);
939 EXPECT_EQ(ret4, false);
940
941 auto ret5 = OH_ArkUI_SetGestureRecognizerLimitFingerCount(recognizer, true);
942 EXPECT_EQ(ret5, ARKUI_ERROR_CODE_PARAM_INVALID);
943 }
944
945 /**
946 * @tc.name: GestureImplTest0012
947 * @tc.desc: Test the OH_ArkUI_GetGestureRecognizerState function.
948 * @tc.type: FUNC
949 */
950 HWTEST_F(NativeGestureTest, GestureImplTest0012, TestSize.Level1)
951 {
952 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
953 ArkUI_GestureRecognizerState state;
954 auto ret1 = OH_ArkUI_GetGestureRecognizerState(nullptr, &state);
955 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
956 auto ret2 = OH_ArkUI_GetGestureRecognizerState(recognizer, &state);
957 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
958 }
959
960 /**
961 * @tc.name: GestureImplTest0013
962 * @tc.desc: Test the OH_ArkUI_GetGestureEventTargetInfo function.
963 * @tc.type: FUNC
964 */
965 HWTEST_F(NativeGestureTest, GestureImplTest0013, TestSize.Level1)
966 {
967 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
968 ArkUI_GestureEventTargetInfo* info = nullptr;
969 auto ret1 = OH_ArkUI_GetGestureEventTargetInfo(nullptr, &info);
970 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
971 auto ret2 = OH_ArkUI_GetGestureEventTargetInfo(recognizer, &info);
972 EXPECT_EQ(ret2, 0);
973 EXPECT_NE(info, nullptr);
974 }
975
976 /**
977 * @tc.name: GestureImplTest0014
978 * @tc.desc: Test the OH_ArkUI_GestureEventTargetInfo_IsScrollBegin function.
979 * @tc.type: FUNC
980 */
981 HWTEST_F(NativeGestureTest, GestureImplTest0014, TestSize.Level1)
982 {
983 ArkUI_GestureEventTargetInfo info;
984 bool ret = false;
985 auto ret1 = OH_ArkUI_GestureEventTargetInfo_IsScrollBegin(nullptr, &ret);
986 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
987 auto ret2 = OH_ArkUI_GestureEventTargetInfo_IsScrollBegin(&info, &ret);
988 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
989 }
990
991 /**
992 * @tc.name: GestureImplTest0015
993 * @tc.desc: Test the OH_ArkUI_GestureEventTargetInfo_IsScrollEnd function.
994 * @tc.type: FUNC
995 */
996 HWTEST_F(NativeGestureTest, GestureImplTest0015, TestSize.Level1)
997 {
998 ArkUI_GestureEventTargetInfo info;
999 bool ret = false;
1000 auto ret1 = OH_ArkUI_GestureEventTargetInfo_IsScrollEnd(nullptr, &ret);
1001 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
1002 auto ret2 = OH_ArkUI_GestureEventTargetInfo_IsScrollEnd(&info, &ret);
1003 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
1004 }
1005
1006 /**
1007 * @tc.name: GestureImplTest0016
1008 * @tc.desc: Test the OH_ArkUI_GetPanGestureDirectionMask function.
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(NativeGestureTest, GestureImplTest0016, TestSize.Level1)
1012 {
1013 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
1014 ArkUI_GestureDirectionMask mask;
1015 auto ret1 = OH_ArkUI_GetPanGestureDirectionMask(nullptr, &mask);
1016 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
1017 auto ret2 = OH_ArkUI_GetPanGestureDirectionMask(recognizer, &mask);
1018 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
1019 }
1020
1021 /**
1022 * @tc.name: GestureImplTest0017
1023 * @tc.desc: Test the OH_ArkUI_IsBuiltInGesture function.
1024 * @tc.type: FUNC
1025 */
1026 HWTEST_F(NativeGestureTest, GestureImplTest0017, TestSize.Level1)
1027 {
1028 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
1029 auto ret1 = OH_ArkUI_IsBuiltInGesture(nullptr);
1030 EXPECT_EQ(ret1, false);
1031 auto ret2 = OH_ArkUI_IsBuiltInGesture(recognizer);
1032 EXPECT_EQ(ret2, false);
1033 }
1034
1035 /**
1036 * @tc.name: GestureImplTest0018
1037 * @tc.desc: Test the OH_ArkUI_GetGestureTag function.
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(NativeGestureTest, GestureImplTest0018, TestSize.Level1)
1041 {
1042 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
1043 char buffer[100];
1044 int32_t bufferSize = 100;
1045 int32_t result = 0;
1046 auto ret1 = OH_ArkUI_GetGestureTag(nullptr, buffer, bufferSize, &result);
1047 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
1048 auto ret2 = OH_ArkUI_GetGestureTag(recognizer, buffer, bufferSize, &result);
1049 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
1050 }
1051
1052 /**
1053 * @tc.name: GestureImplTest0019
1054 * @tc.desc: Test the OH_ArkUI_GetGestureBindNodeId function.
1055 * @tc.type: FUNC
1056 */
1057 HWTEST_F(NativeGestureTest, GestureImplTest0019, TestSize.Level1)
1058 {
1059 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
1060 char nodeId[128];
1061 std::fill_n(nodeId, sizeof(nodeId), 0);
1062 auto ret1 = OH_ArkUI_GetGestureBindNodeId(nullptr, nodeId, sizeof(nodeId), nullptr);
1063 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
1064 auto ret2 = OH_ArkUI_GetGestureBindNodeId(recognizer, nodeId, sizeof(nodeId), nullptr);
1065 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
1066 }
1067
1068 /**
1069 * @tc.name: GestureImplTest0020
1070 * @tc.desc: Test the OH_ArkUI_IsGestureRecognizerValid function.
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F(NativeGestureTest, GestureImplTest0020, TestSize.Level1)
1074 {
1075 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
1076 auto ret1 = OH_ArkUI_IsGestureRecognizerValid(nullptr);
1077 EXPECT_EQ(ret1, false);
1078 auto ret2 = OH_ArkUI_IsGestureRecognizerValid(recognizer);
1079 EXPECT_EQ(ret2, false);
1080 }
1081
1082 /**
1083 * @tc.name: GestureImplTest0021
1084 * @tc.desc: Test the OH_ArkUI_ParallelInnerGestureEvent_GetUserData function.
1085 * @tc.type: FUNC
1086 */
1087 HWTEST_F(NativeGestureTest, GestureImplTest0021, TestSize.Level1)
1088 {
1089 auto *event = new ArkUI_ParallelInnerGestureEvent();
1090 auto ret1 = OH_ArkUI_ParallelInnerGestureEvent_GetUserData(event);
1091 EXPECT_EQ(ret1, nullptr);
1092 }
1093
1094 /**
1095 * @tc.name: GestureImplTest0022
1096 * @tc.desc: Test the OH_ArkUI_ParallelInnerGestureEvent_GetCurrentRecognizer function.
1097 * @tc.type: FUNC
1098 */
1099 HWTEST_F(NativeGestureTest, GestureImplTest0022, TestSize.Level1)
1100 {
1101 auto *event = new ArkUI_ParallelInnerGestureEvent();
1102 auto ret1 = OH_ArkUI_ParallelInnerGestureEvent_GetCurrentRecognizer(event);
1103 EXPECT_EQ(ret1, nullptr);
1104 }
1105
1106 /**
1107 * @tc.name: GestureImplTest0023
1108 * @tc.desc: Test the OH_ArkUI_ParallelInnerGestureEvent_GetConflictRecognizers function.
1109 * @tc.type: FUNC
1110 */
1111 HWTEST_F(NativeGestureTest, GestureImplTest0023, TestSize.Level1)
1112 {
1113 ArkUI_ParallelInnerGestureEvent *event = new ArkUI_ParallelInnerGestureEvent();
1114 ArkUI_GestureRecognizerHandleArray array;
1115 int32_t size = 0;
1116 event->count = 10;
1117 auto ret1 = OH_ArkUI_ParallelInnerGestureEvent_GetConflictRecognizers(event, nullptr, &size);
1118 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
1119 auto ret2 = OH_ArkUI_ParallelInnerGestureEvent_GetConflictRecognizers(event, &array, nullptr);
1120 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
1121 auto ret3 = OH_ArkUI_ParallelInnerGestureEvent_GetConflictRecognizers(event, &array, &size);
1122 EXPECT_EQ(ret3, 0);
1123 EXPECT_EQ(size, 10);
1124 }
1125
1126 /**
1127 * @tc.name: GestureImplTest0024
1128 * @tc.desc: Test the OH_ArkUI_SetArkUIGestureRecognizerDisposeNotify function.
1129 * @tc.type: FUNC
1130 */
1131 HWTEST_F(NativeGestureTest, GestureImplTest0024, TestSize.Level1)
1132 {
1133 ArkUI_GestureRecognizer recognizer;
1134 ArkUI_GestureRecognizerDisposeNotifyCallback callback = nullptr;
1135 auto ret1 = OH_ArkUI_SetArkUIGestureRecognizerDisposeNotify(nullptr, callback, nullptr);
1136 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID);
1137 auto ret2 = OH_ArkUI_SetArkUIGestureRecognizerDisposeNotify(&recognizer, callback, nullptr);
1138 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID);
1139 }
1140
1141 /**
1142 * @tc.name: GestureImplTest0025
1143 * @tc.desc: Test the CreateTapGesture function.
1144 * @tc.type: FUNC
1145 */
1146 HWTEST_F(NativeGestureTest, GestureImplTest0025, TestSize.Level1)
1147 {
1148 int32_t count = 1;
1149 int32_t fingers = 11;
1150 auto ret = OHOS::Ace::GestureModel::CreateTapGesture(count, fingers);
1151 EXPECT_NE(ret, nullptr);
1152 }
1153
1154 /**
1155 * @tc.name: GestureImplTest0026
1156 * @tc.desc: Test the CreateTapGestureWithDistanceThreshold function.
1157 * @tc.type: FUNC
1158 */
1159 HWTEST_F(NativeGestureTest, GestureImplTest0026, TestSize.Level1)
1160 {
1161 int32_t count = 1;
1162 int32_t fingers = 11;
1163 double distanceThreshold = 10.0;
1164 auto ret = OHOS::Ace::GestureModel::CreateTapGestureWithDistanceThreshold(count, fingers, distanceThreshold);
1165 EXPECT_NE(ret, nullptr);
1166 }
1167
1168 /**
1169 * @tc.name: GestureImplTest0027
1170 * @tc.desc: Test the CreateLongPressGesture function.
1171 * @tc.type: FUNC
1172 */
1173 HWTEST_F(NativeGestureTest, GestureImplTest0027, TestSize.Level1)
1174 {
1175 int32_t fingers = 11;
1176 bool repeatResult = true;
1177 int32_t duration = 100;
1178 auto ret = OHOS::Ace::GestureModel::CreateLongPressGesture(fingers, repeatResult, duration);
1179 EXPECT_NE(ret, nullptr);
1180 }
1181
1182 /**
1183 * @tc.name: GestureImplTest0028
1184 * @tc.desc: Test the CreateLongPressGesture function.
1185 * @tc.type: FUNC
1186 */
1187 HWTEST_F(NativeGestureTest, GestureImplTest0028, TestSize.Level1)
1188 {
1189 int32_t fingers = 11;
1190 bool repeatResult = true;
1191 int32_t duration = 100;
1192 auto ret = OHOS::Ace::GestureModel::CreateLongPressGesture(fingers, repeatResult, duration);
1193 EXPECT_NE(ret, nullptr);
1194 }
1195
1196 /**
1197 * @tc.name: GestureImplTest0029
1198 * @tc.desc: Test the CreatePinchGesture function.
1199 * @tc.type: FUNC
1200 */
1201 HWTEST_F(NativeGestureTest, GestureImplTest0029, TestSize.Level1)
1202 {
1203 int32_t fingers = 11;
1204 double distance1 = 10.0;
1205 auto ret1 = OHOS::Ace::GestureModel::CreatePinchGesture(fingers, distance1);
1206 EXPECT_NE(ret1, nullptr);
1207 double distance2 = 0.0;
1208 auto ret2 = OHOS::Ace::GestureModel::CreatePinchGesture(fingers, distance2);
1209 EXPECT_NE(ret2, nullptr);
1210 }
1211
1212 /**
1213 * @tc.name: GestureImplTest0030
1214 * @tc.desc: Test the CreateRotationGesture function.
1215 * @tc.type: FUNC
1216 */
1217 HWTEST_F(NativeGestureTest, GestureImplTest0030, TestSize.Level1)
1218 {
1219 int32_t fingers = 11;
1220 double angle = 10.0;
1221 auto ret = OHOS::Ace::GestureModel::CreateRotationGesture(fingers, angle);
1222 EXPECT_NE(ret, nullptr);
1223 }
1224
1225 /**
1226 * @tc.name: GestureImplTest0031
1227 * @tc.desc: Test the CreateSwipeGesture function.
1228 * @tc.type: FUNC
1229 */
1230 HWTEST_F(NativeGestureTest, GestureImplTest0031, TestSize.Level1)
1231 {
1232 int32_t fingers = 11;
1233 ArkUI_GestureDirectionMask directions = 1;
1234 double speed1 = 10.0;
1235 auto ret1 = OHOS::Ace::GestureModel::CreateSwipeGesture(fingers, directions, speed1);
1236 EXPECT_NE(ret1, nullptr);
1237 double speed2 = 0.0;
1238 auto ret2 = OHOS::Ace::GestureModel::CreateSwipeGesture(fingers, directions, speed2);
1239 EXPECT_NE(ret2, nullptr);
1240 }
1241
1242 /**
1243 * @tc.name: GestureImplTest0032
1244 * @tc.desc: Test the CreatePanGesture function.
1245 * @tc.type: FUNC
1246 */
1247 HWTEST_F(NativeGestureTest, GestureImplTest0032, TestSize.Level1)
1248 {
1249 int32_t fingers = 2;
1250 ArkUI_GestureDirectionMask directions = 1;
1251 double distanceNum = 10.0;
1252 auto ret1 = OHOS::Ace::GestureModel::CreatePanGesture(fingers, directions, distanceNum);
1253 EXPECT_NE(ret1, nullptr);
1254 fingers = 20;
1255 auto ret2 = OHOS::Ace::GestureModel::CreatePanGesture(fingers, directions, distanceNum);
1256 EXPECT_NE(ret2, nullptr);
1257 }
1258
1259 /**
1260 * @tc.name: GestureImplTest0033
1261 * @tc.desc: Test the DisposeGesture function.
1262 * @tc.type: FUNC
1263 */
1264 HWTEST_F(NativeGestureTest, GestureImplTest0033, TestSize.Level1)
1265 {
1266 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_2*>(
1267 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_2"));
1268 auto longPressGesture = gestureAPI->gestureApi1->createLongPressGesture(1, true, 500);
1269 OHOS::Ace::GestureModel::DisposeGesture(longPressGesture);
1270 EXPECT_EQ(longPressGesture->extraData, nullptr);
1271 }
1272
1273 /**
1274 * @tc.name: GestureImplTest0034
1275 * @tc.desc: Test the SetGestureEventTarget function.
1276 * @tc.type: FUNC
1277 */
1278 HWTEST_F(NativeGestureTest, GestureImplTest0034, TestSize.Level1)
1279 {
1280 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_2*>(
1281 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_2"));
1282 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1283 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1284 auto gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
1285 auto longPressGesture = gestureAPI->gestureApi1->createLongPressGesture(1, true, 500);
__anon5b7370ad0502(ArkUI_GestureEvent *event, void *extraParam) 1286 auto onActionCallBack = [](ArkUI_GestureEvent *event, void *extraParam) {};
1287 auto ret = OHOS::Ace::GestureModel::SetGestureEventTarget(
1288 longPressGesture, GESTURE_EVENT_ACTION_ACCEPT, gestureNode, onActionCallBack);
1289 EXPECT_EQ(ret, 0);
1290 }
1291
1292 /**
1293 * @tc.name: GestureImplTest0035
1294 * @tc.desc: Test the AddGestureToNode function.
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(NativeGestureTest, GestureImplTest0035, TestSize.Level1)
1298 {
1299 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_2*>(
1300 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_2"));
1301 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1302 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1303 auto gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
1304 auto longPressGesture = gestureAPI->gestureApi1->createLongPressGesture(1, true, 500);
1305 auto ret = OHOS::Ace::GestureModel::AddGestureToNode(gestureNode, longPressGesture, PRIORITY, NORMAL_GESTURE_MASK);
1306 EXPECT_EQ(ret, 0);
1307 }
1308
1309 /**
1310 * @tc.name: GestureImplTest0036
1311 * @tc.desc: Test the RemoveGestureFromNode function.
1312 * @tc.type: FUNC
1313 */
1314 HWTEST_F(NativeGestureTest, GestureImplTest0036, TestSize.Level1)
1315 {
1316 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_2*>(
1317 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_2"));
1318 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1319 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1320 auto gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
1321 auto longPressGesture = gestureAPI->gestureApi1->createLongPressGesture(1, true, 500);
1322 auto ret = OHOS::Ace::GestureModel::RemoveGestureFromNode(gestureNode, longPressGesture);
1323 EXPECT_EQ(longPressGesture->targetInfo.uiNode, nullptr);
1324 EXPECT_EQ(ret, 0);
1325 }
1326
1327 /**
1328 * @tc.name: GestureImplTest0037
1329 * @tc.desc: Test the CreateGroupGesture function.
1330 * @tc.type: FUNC
1331 */
1332 HWTEST_F(NativeGestureTest, GestureImplTest0037, TestSize.Level1)
1333 {
1334 auto ret = OHOS::Ace::GestureModel::CreateGroupGesture(EXCLUSIVE_GROUP);
1335 EXPECT_NE(ret, nullptr);
1336 }
1337
1338 /**
1339 * @tc.name: GestureImplTest0038
1340 * @tc.desc: Test the AddChildGesture function.
1341 * @tc.type: FUNC
1342 */
1343 HWTEST_F(NativeGestureTest, GestureImplTest0038, TestSize.Level1)
1344 {
1345 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_2*>(
1346 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_2"));
1347 auto group = gestureAPI->gestureApi1->createGroupGesture(EXCLUSIVE_GROUP);
1348 auto tapGesture = gestureAPI->gestureApi1->createTapGesture(1, 1);
1349 auto ret = OHOS::Ace::GestureModel::AddChildGesture(group, tapGesture);
1350 EXPECT_EQ(ret, 0);
1351 }
1352
1353 /**
1354 * @tc.name: GestureImplTest0039
1355 * @tc.desc: Test the GetGestureType function.
1356 * @tc.type: FUNC
1357 */
1358 HWTEST_F(NativeGestureTest, GestureImplTest0039, TestSize.Level1)
1359 {
1360 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_2*>(
1361 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_2"));
1362 auto longPressGesture = gestureAPI->gestureApi1->createLongPressGesture(1, true, 500);
1363 longPressGesture->type = 2;
1364 auto ret = OHOS::Ace::GestureModel::GetGestureType(longPressGesture);
1365 EXPECT_EQ(ret, 2);
1366 }
1367
1368 /**
1369 * @tc.name: GestureImplTest0040
1370 * @tc.desc: Test the RemoveChildGesture function.
1371 * @tc.type: FUNC
1372 */
1373 HWTEST_F(NativeGestureTest, GestureImplTest0040, TestSize.Level1)
1374 {
1375 auto gestureAPI = reinterpret_cast<ArkUI_NativeGestureAPI_2*>(
1376 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_2"));
1377 auto group = gestureAPI->gestureApi1->createGroupGesture(EXCLUSIVE_GROUP);
1378 auto tapGesture = gestureAPI->gestureApi1->createTapGesture(1, 1);
1379 auto ret = OHOS::Ace::GestureModel::RemoveChildGesture(group, tapGesture);
1380 EXPECT_EQ(ret, 0);
1381 }
1382
1383 /**
1384 * @tc.name: GestureImplTest0041
1385 * @tc.desc: Test the HandleGestureEvent function.
1386 * @tc.type: FUNC
1387 */
MockTargetReceiver(ArkUI_GestureEvent * event,void * extraParam)1388 void MockTargetReceiver(ArkUI_GestureEvent* event, void* extraParam)
1389 {
1390 EXPECT_NE(event->eventData.rawPointerEvent, nullptr);
1391 }
MockTargetReceiver2(ArkUI_GestureEvent * event,void * extraParam)1392 void MockTargetReceiver2(ArkUI_GestureEvent* event, void* extraParam)
1393 {
1394 EXPECT_NE(event->eventData.rawPointerEvent, nullptr);
1395 EXPECT_EQ(event->attachNode, nullptr);
1396 }
1397 HWTEST_F(NativeGestureTest, GestureImplTest0041, TestSize.Level1)
1398 {
1399 ArkUINodeEvent* event1 = nullptr;
1400 OHOS::Ace::GestureModel::HandleGestureEvent(event1);
1401 EXPECT_EQ(event1, nullptr);
1402
1403 ArkUINodeEvent event2;
1404 event2.extraParam = 0;
1405 OHOS::Ace::GestureModel::HandleGestureEvent(&event2);
1406 EXPECT_EQ(event2.extraParam, 0);
1407
1408 ArkUINodeEvent event3 = {0};
1409 OHOS::Ace::GestureModel::GestureInnerData extraData;
1410 extraData.gesture = nullptr;
1411 extraData.targetReceiver = MockTargetReceiver;
1412 extraData.extraParam = nullptr;
1413 event3.kind = ArkUIEventCategory::GESTURE_ASYNC_EVENT;
1414 event3.extraParam = reinterpret_cast<ArkUI_Int64>(&extraData);
1415 event3.gestureAsyncEvent.inputEventType = static_cast<int32_t>(ARKUI_UIINPUTEVENT_TYPE_MOUSE);
1416 event3.gestureAsyncEvent.rawPointerEvent = nullptr;
1417 OHOS::Ace::GestureModel::HandleGestureEvent(&event3);
1418 event3.gestureAsyncEvent.rawPointerEvent = nullptr;
1419 event3.kind = ArkUIEventCategory::INVALID;
1420 event3.gestureAsyncEvent.inputEventType = static_cast<int32_t>(ARKUI_UIINPUTEVENT_TYPE_AXIS);
1421 OHOS::Ace::GestureModel::HandleGestureEvent(&event3);
1422 event3.gestureAsyncEvent.rawPointerEvent = nullptr;
1423 event3.gestureAsyncEvent.inputEventType = static_cast<int32_t>(ARKUI_UIINPUTEVENT_TYPE_TOUCH);
1424 OHOS::Ace::GestureModel::HandleGestureEvent(&event3);
1425
1426 ArkUI_GestureRecognizer *recognizer = new ArkUI_GestureRecognizer();
1427 recognizer->attachNode = nullptr;
1428 extraData.gesture = reinterpret_cast<ArkUI_GestureRecognizer*>(recognizer);
1429 extraData.targetReceiver = MockTargetReceiver2;
1430 event3.extraParam = reinterpret_cast<ArkUI_Int64>(&extraData);
1431 OHOS::Ace::GestureModel::HandleGestureEvent(&event3);
1432 }
1433
1434 /**
1435 * @tc.name: GestureImplTest0042
1436 * @tc.desc: Test the SetGestureInterrupterToNode function.
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(NativeGestureTest, GestureImplTest0042, TestSize.Level1)
1440 {
__anon5b7370ad0602(ArkUI_GestureInterruptInfo* info) 1441 auto interrupter = [](ArkUI_GestureInterruptInfo* info) -> ArkUI_GestureInterruptResult {
1442 return ArkUI_GestureInterruptResult::GESTURE_INTERRUPT_RESULT_CONTINUE;
1443 };
1444 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1445 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1446 auto gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
1447 auto ret = OHOS::Ace::GestureModel::SetGestureInterrupterToNode(gestureNode, interrupter);
1448 EXPECT_EQ(ret, 0);
1449 }
1450
1451 /**
1452 * @tc.name: GestureImplTest0043
1453 * @tc.desc: Test the SetGestureInterrupterToNodeWithUserData function.
1454 * @tc.type: FUNC
1455 */
1456 HWTEST_F(NativeGestureTest, GestureImplTest0043, TestSize.Level1)
1457 {
__anon5b7370ad0702(ArkUI_GestureInterruptInfo* info) 1458 auto interrupter = [](ArkUI_GestureInterruptInfo* info) -> ArkUI_GestureInterruptResult {
1459 return ArkUI_GestureInterruptResult::GESTURE_INTERRUPT_RESULT_CONTINUE;
1460 };
1461 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1462 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1463 auto gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
1464 void* userData = reinterpret_cast<void*>(new int);
1465 auto ret = OHOS::Ace::GestureModel::SetGestureInterrupterToNodeWithUserData(gestureNode, userData, interrupter);
1466 EXPECT_EQ(ret, 0);
1467 }
1468
1469 /**
1470 * @tc.name: GestureImplTest0044
1471 * @tc.desc: Test the SetInnerGestureParallelTo function.
1472 * @tc.type: FUNC
1473 */
1474 HWTEST_F(NativeGestureTest, GestureImplTest0044, TestSize.Level1)
1475 {
1476 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1477 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1478 auto gestureNode = nodeAPI->createNode(ARKUI_NODE_STACK);
1479 void* userData = reinterpret_cast<void*>(new int);
1480 auto ret = OHOS::Ace::GestureModel::SetInnerGestureParallelTo(gestureNode, userData, nullptr);
1481 EXPECT_EQ(ret, 0);
1482 }