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 "animate_impl.h"
17 #include "core/interfaces/arkoala/arkoala_api.h"
18 #include "error_code.h"
19 #include "event_converter.h"
20 #include "gtest/gtest.h"
21 #include "native_animate.h"
22 #include "native_interface.h"
23 #include "native_node.h"
24 #include "node_extened.h"
25 #include "node_model.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace OHOS::Ace::NodeModel;
30 
31 class NodeExtenedTest : public testing::Test {
32 public:
SetUpTestCase()33     static void SetUpTestCase()
34     {
35         InitialFullImpl();
36     };
TearDownTestCase()37     static void TearDownTestCase() {};
38 };
39 
EventReceiverHandle(ArkUI_NodeCustomEvent * event)40 void EventReceiverHandle(ArkUI_NodeCustomEvent* event) {}
41 /**
42  * @tc.name: NodeExtenedTest001
43  * @tc.desc: Test NodeAddExtraData function.
44  * @tc.type: FUNC
45  */
46 HWTEST_F(NodeExtenedTest, NodeExtenedTest001, TestSize.Level1)
47 {
48     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
49     ASSERT_NE(nodeHandle, nullptr);
50 
51     void* userData = nullptr;
52     NodeAddExtraData(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE, 0, userData);
53     ASSERT_NE(nodeHandle->extraCustomData, nullptr);
54     DisposeNode(nodeHandle);
55     nodeHandle = nullptr;
56 }
57 
58 /**
59  * @tc.name: NodeExtenedTest002
60  * @tc.desc: Test RegisterNodeCustomEvent function.
61  * @tc.type: FUNC
62  */
63 HWTEST_F(NodeExtenedTest, NodeExtenedTest002, TestSize.Level1)
64 {
65     void* userData = nullptr;
66     int32_t ret = RegisterNodeCustomEvent(nullptr, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE,
67                                           0, userData);
68     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
69 }
70 
71 /**
72  * @tc.name: NodeExtenedTest003
73  * @tc.desc: Test RegisterNodeCustomEvent function.
74  * @tc.type: FUNC
75  */
76 HWTEST_F(NodeExtenedTest, NodeExtenedTest003, TestSize.Level1)
77 {
78     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
79     ASSERT_NE(nodeHandle, nullptr);
80 
81     void* userData = nullptr;
82     int32_t ret = RegisterNodeCustomEvent(nodeHandle, static_cast<ArkUI_NodeCustomEventType>(-1), 0, userData);
83     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NATIVE_IMPL_TYPE_NOT_SUPPORTED);
84 
85     DisposeNode(nodeHandle);
86     nodeHandle = nullptr;
87 }
88 
89 /**
90  * @tc.name: NodeExtenedTest004
91  * @tc.desc: Test RegisterNodeCustomEvent function.
92  * @tc.type: FUNC
93  */
94 HWTEST_F(NodeExtenedTest, NodeExtenedTest004, TestSize.Level1)
95 {
96     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
97     ASSERT_NE(nodeHandle, nullptr);
98 
99     void* userData = nullptr;
100     int32_t ret = RegisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE,
101                                           0, userData);
102     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NATIVE_IMPL_TYPE_NOT_SUPPORTED);
103 
104     DisposeNode(nodeHandle);
105     nodeHandle = nullptr;
106 }
107 
108 /**
109  * @tc.name: NodeExtenedTest005
110  * @tc.desc: Test RegisterNodeCustomEvent function.
111  * @tc.type: FUNC
112  */
113 HWTEST_F(NodeExtenedTest, NodeExtenedTest005, TestSize.Level1)
114 {
115     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
116     ASSERT_NE(nodeHandle, nullptr);
117     nodeHandle->type = ArkUI_NodeType::ARKUI_NODE_CUSTOM;
118     void* userData = nullptr;
119     int32_t ret = RegisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE,
120                                           0, userData);
121     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
122     UnregisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE);
123     ASSERT_EQ(nodeHandle->extraCustomData, nullptr);
124     DisposeNode(nodeHandle);
125     nodeHandle = nullptr;
126 }
127 
128 /**
129  * @tc.name: NodeExtenedTest006
130  * @tc.desc: Test RegisterNodeCustomEvent function.
131  * @tc.type: FUNC
132  */
133 HWTEST_F(NodeExtenedTest, NodeExtenedTest006, TestSize.Level1)
134 {
135     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
136     ASSERT_NE(nodeHandle, nullptr);
137 
138     void* userData = nullptr;
139     int32_t ret = RegisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_LAYOUT,
140                                           0, userData);
141     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NATIVE_IMPL_TYPE_NOT_SUPPORTED);
142 
143     DisposeNode(nodeHandle);
144     nodeHandle = nullptr;
145 }
146 
147 /**
148  * @tc.name: NodeExtenedTest007
149  * @tc.desc: Test RegisterNodeCustomEvent function.
150  * @tc.type: FUNC
151  */
152 HWTEST_F(NodeExtenedTest, NodeExtenedTest007, TestSize.Level1)
153 {
154     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
155     ASSERT_NE(nodeHandle, nullptr);
156     nodeHandle->type = ArkUI_NodeType::ARKUI_NODE_CUSTOM;
157     void* userData = nullptr;
158     int32_t ret = RegisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_LAYOUT,
159                                           0, userData);
160     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
161     UnregisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_LAYOUT);
162     ASSERT_EQ(nodeHandle->extraCustomData, nullptr);
163     DisposeNode(nodeHandle);
164     nodeHandle = nullptr;
165 }
166 
167 /**
168  * @tc.name: NodeExtenedTest008
169  * @tc.desc: Test RegisterNodeCustomEvent function.
170  * @tc.type: FUNC
171  */
172 HWTEST_F(NodeExtenedTest, NodeExtenedTest008, TestSize.Level1)
173 {
174     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
175     ASSERT_NE(nodeHandle, nullptr);
176     nodeHandle->type = ArkUI_NodeType::ARKUI_NODE_CUSTOM;
177     void* userData = nullptr;
178     int32_t ret = RegisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_DRAW,
179                                           0, userData);
180     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
181     UnregisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_DRAW);
182     ASSERT_EQ(nodeHandle->extraCustomData, nullptr);
183     DisposeNode(nodeHandle);
184     nodeHandle = nullptr;
185 }
186 
187 /**
188  * @tc.name: NodeExtenedTest009
189  * @tc.desc: Test RegisterNodeCustomEvent function.
190  * @tc.type: FUNC
191  */
192 HWTEST_F(NodeExtenedTest, NodeExtenedTest009, TestSize.Level1)
193 {
194     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
195     ASSERT_NE(nodeHandle, nullptr);
196     nodeHandle->type = ArkUI_NodeType::ARKUI_NODE_CUSTOM;
197     void* userData = nullptr;
198     int32_t ret = RegisterNodeCustomEvent(nodeHandle,
199         ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_FOREGROUND_DRAW, 0, userData);
200     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
201     UnregisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_FOREGROUND_DRAW);
202     ASSERT_EQ(nodeHandle->extraCustomData, nullptr);
203     DisposeNode(nodeHandle);
204     nodeHandle = nullptr;
205 }
206 
207 /**
208  * @tc.name: NodeExtenedTest010
209  * @tc.desc: Test RegisterNodeCustomEvent function.
210  * @tc.type: FUNC
211  */
212 HWTEST_F(NodeExtenedTest, NodeExtenedTest010, TestSize.Level1)
213 {
214     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
215     ASSERT_NE(nodeHandle, nullptr);
216     nodeHandle->type = ArkUI_NodeType::ARKUI_NODE_CUSTOM;
217     void* userData = nullptr;
218     int32_t ret = RegisterNodeCustomEvent(nodeHandle,
219         ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_OVERLAY_DRAW, 0, userData);
220     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
221     UnregisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_OVERLAY_DRAW);
222     ASSERT_EQ(nodeHandle->extraCustomData, nullptr);
223     DisposeNode(nodeHandle);
224     nodeHandle = nullptr;
225 }
226 
227 /**
228  * @tc.name: NodeExtenedTest011
229  * @tc.desc: Test NodeRemoveExtraData function.
230  * @tc.type: FUNC
231  */
232 HWTEST_F(NodeExtenedTest, NodeExtenedTest011, TestSize.Level1)
233 {
234     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
235     ASSERT_NE(nodeHandle, nullptr);
236 
237     void* userData = nullptr;
238     NodeAddExtraData(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE, 0, userData);
239     ASSERT_NE(nodeHandle->extraCustomData, nullptr);
240     NodeRemoveExtraData(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE);
241     ASSERT_EQ(nodeHandle->extraCustomData, nullptr);
242     DisposeNode(nodeHandle);
243     nodeHandle = nullptr;
244 }
245 
246 /**
247  * @tc.name: NodeExtenedTest012
248  * @tc.desc: Test NodeRemoveExtraData function.
249  * @tc.type: FUNC
250  */
251 HWTEST_F(NodeExtenedTest, NodeExtenedTest012, TestSize.Level1)
252 {
253     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
254     ASSERT_NE(nodeHandle, nullptr);
255 
256     void* userData = nullptr;
257     NodeAddExtraData(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE, 0, userData);
258     NodeRemoveExtraData(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_OVERLAY_DRAW);
259     ASSERT_NE(nodeHandle->extraCustomData, nullptr);
260     DisposeNode(nodeHandle);
261     nodeHandle = nullptr;
262 }
263 
264 /**
265  * @tc.name: NodeExtenedTest013
266  * @tc.desc: Test UnregisterNodeCustomEvent function.
267  * @tc.type: FUNC
268  */
269 HWTEST_F(NodeExtenedTest, NodeExtenedTest013, TestSize.Level1)
270 {
271     UnregisterNodeCustomEvent(nullptr, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE);
272     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
273     ASSERT_NE(nodeHandle, nullptr);
274     nodeHandle->type = ArkUI_NodeType::ARKUI_NODE_CUSTOM;
275     void* userData = nullptr;
276     int32_t ret = RegisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE,
277                                           0, userData);
278     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
279     UnregisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE);
280     ASSERT_EQ(nodeHandle->extraCustomData, nullptr);
281     DisposeNode(nodeHandle);
282     nodeHandle = nullptr;
283 }
284 
285 /**
286  * @tc.name: NodeExtenedTest014
287  * @tc.desc: Test UnregisterNodeCustomEvent function.
288  * @tc.type: FUNC
289  */
290 HWTEST_F(NodeExtenedTest, NodeExtenedTest014, TestSize.Level1)
291 {
292     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
293     ASSERT_NE(nodeHandle, nullptr);
294     nodeHandle->type = ArkUI_NodeType::ARKUI_NODE_CUSTOM;
295     void* userData = nullptr;
296     int32_t ret = RegisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE,
297                                           0, userData);
298     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
299     UnregisterNodeCustomEvent(nodeHandle, ArkUI_NodeCustomEventType::ARKUI_NODE_CUSTOM_EVENT_ON_OVERLAY_DRAW);
300     ASSERT_NE(nodeHandle->extraCustomData, nullptr);
301     DisposeNode(nodeHandle);
302     nodeHandle = nullptr;
303 }
304 
305 /**
306  * @tc.name: NodeExtenedTest015
307  * @tc.desc: Test HandleCustomEvent function.
308  * @tc.type: FUNC
309  */
310 HWTEST_F(NodeExtenedTest, NodeExtenedTest015, TestSize.Level1)
311 {
312     HandleCustomEvent(nullptr);
313     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
314     ASSERT_NE(nodeHandle, nullptr);
315     nodeHandle->customEventListeners = new std::set<void (*)(ArkUI_NodeCustomEvent*)>();
316     ArkUI_NodeCustomEvent event;
317     event.node = nodeHandle;
318     RegisterNodeCustomReceiver(EventReceiverHandle);
319     HandleCustomEvent(&event);
320 
321     int32_t ret = SetMeasuredSize(nullptr, 0, 0);
322     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
323     ret = SetMeasuredSize(nodeHandle, 1, 1);
324     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
325     ArkUI_IntSize size = GetMeasuredSize(nodeHandle);
326     ASSERT_EQ(size.width, 1);
327     ASSERT_EQ(size.height, 1);
328     DisposeNode(nodeHandle);
329     nodeHandle = nullptr;
330 }
331 
332 /**
333  * @tc.name: NodeExtenedTest016
334  * @tc.desc: Test HandleCustomEvent function.
335  * @tc.type: FUNC
336  */
337 HWTEST_F(NodeExtenedTest, NodeExtenedTest016, TestSize.Level1)
338 {
339     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
340     ASSERT_NE(nodeHandle, nullptr);
341     nodeHandle->customEventListeners = new std::set<void (*)(ArkUI_NodeCustomEvent*)>();
342     ArkUI_NodeCustomEvent event;
343     event.node = nodeHandle;
344     UnregisterNodeCustomEventReceiver();
345     HandleCustomEvent(&event);
346 
347     int32_t ret = SetLayoutPosition(nullptr, 0, 0);
348     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
349     ret = SetLayoutPosition(nodeHandle, 1, 1);
350     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
351     ArkUI_IntOffset offset = GetLayoutPosition(nodeHandle);
352     ASSERT_EQ(offset.x, 1);
353     ASSERT_EQ(offset.y, 1);
354     DisposeNode(nodeHandle);
355     nodeHandle = nullptr;
356 }
357 
358 /**
359  * @tc.name: NodeExtenedTest017
360  * @tc.desc: Test HandleInnerCustomEvent function.
361  * @tc.type: FUNC
362  */
363 HWTEST_F(NodeExtenedTest, NodeExtenedTest017, TestSize.Level1)
364 {
365     HandleInnerCustomEvent(nullptr);
366     struct ArkUICustomNodeEvent* arkUICustomNodeEvent = new ArkUICustomNodeEvent();
367     ASSERT_NE(arkUICustomNodeEvent, nullptr);
368     HandleInnerCustomEvent(arkUICustomNodeEvent);
369 }
370 
371 /**
372  * @tc.name: NodeExtenedTest018
373  * @tc.desc: Test AddNodeCustomEventReceiver function.
374  * @tc.type: FUNC
375  */
376 HWTEST_F(NodeExtenedTest, NodeExtenedTest018, TestSize.Level1)
377 {
378     int32_t ret = AddNodeCustomEventReceiver(nullptr, nullptr);
379     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
380 }
381 
382 /**
383  * @tc.name: NodeExtenedTest019
384  * @tc.desc: Test AddNodeCustomEventReceiver function.
385  * @tc.type: FUNC
386  */
387 HWTEST_F(NodeExtenedTest, NodeExtenedTest019, TestSize.Level1)
388 {
389     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
390     ASSERT_NE(nodeHandle, nullptr);
391     int32_t ret = AddNodeCustomEventReceiver(nodeHandle, EventReceiverHandle);
392     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
393     DisposeNode(nodeHandle);
394     nodeHandle = nullptr;
395 }
396 
397 /**
398  * @tc.name: NodeExtenedTest020
399  * @tc.desc: Test AddNodeCustomEventReceiver function.
400  * @tc.type: FUNC
401  */
402 HWTEST_F(NodeExtenedTest, NodeExtenedTest020, TestSize.Level1)
403 {
404     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
405     ASSERT_NE(nodeHandle, nullptr);
406     nodeHandle->customEventListeners = new std::set<void (*)(ArkUI_NodeCustomEvent*)>();
407     int32_t ret = AddNodeCustomEventReceiver(nodeHandle, EventReceiverHandle);
408     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
409     DisposeNode(nodeHandle);
410     nodeHandle = nullptr;
411 }
412 
413 /**
414  * @tc.name: NodeExtenedTest021
415  * @tc.desc: Test RemoveNodeCustomEventReceiver function.
416  * @tc.type: FUNC
417  */
418 HWTEST_F(NodeExtenedTest, NodeExtenedTest021, TestSize.Level1)
419 {
420     int32_t ret = RemoveNodeCustomEventReceiver(nullptr, nullptr);
421     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
422 }
423 
424 /**
425  * @tc.name: NodeExtenedTest022
426  * @tc.desc: Test RemoveNodeCustomEventReceiver function.
427  * @tc.type: FUNC
428  */
429 HWTEST_F(NodeExtenedTest, NodeExtenedTest022, TestSize.Level1)
430 {
431     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
432     ASSERT_NE(nodeHandle, nullptr);
433     nodeHandle->customEventListeners = new std::set<void (*)(ArkUI_NodeCustomEvent*)>();
434     int32_t ret = RemoveNodeCustomEventReceiver(nodeHandle, EventReceiverHandle);
435     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
436     DisposeNode(nodeHandle);
437     nodeHandle = nullptr;
438 }
439 
440 /**
441  * @tc.name: NodeExtenedTest023
442  * @tc.desc: Test GetLayoutConstraint function.
443  * @tc.type: FUNC
444  */
445 HWTEST_F(NodeExtenedTest, NodeExtenedTest023, TestSize.Level1)
446 {
447     int32_t ret = GetLayoutConstraint(nullptr, nullptr);
448     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
449     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
450     ASSERT_NE(nodeHandle, nullptr);
451     struct ArkUI_LayoutConstraint layoutConstraint = {0, 0, 0, 0, 0, 0};
452     ret = GetLayoutConstraint(nodeHandle, &layoutConstraint);
453     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
454     DisposeNode(nodeHandle);
455     nodeHandle = nullptr;
456 }
457 
458 /**
459  * @tc.name: NodeExtenedTest024
460  * @tc.desc: Test MeasureNode function.
461  * @tc.type: FUNC
462  */
463 HWTEST_F(NodeExtenedTest, NodeExtenedTest024, TestSize.Level1)
464 {
465     int32_t ret = MeasureNode(nullptr, nullptr);
466     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
467 }
468 
469 /**
470  * @tc.name: NodeExtenedTest025
471  * @tc.desc: Test MeasureNode function.
472  * @tc.type: FUNC
473  */
474 HWTEST_F(NodeExtenedTest, NodeExtenedTest025, TestSize.Level1)
475 {
476     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
477     ASSERT_NE(nodeHandle, nullptr);
478     struct ArkUI_LayoutConstraint layoutConstraint = {0, 0, 0, 0, 0, 0};
479     int32_t ret = MeasureNode(nodeHandle, &layoutConstraint);
480     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
481     DisposeNode(nodeHandle);
482     nodeHandle = nullptr;
483 }
484 
485 /**
486  * @tc.name: NodeExtenedTest026
487  * @tc.desc: Test LayoutNode function.
488  * @tc.type: FUNC
489  */
490 HWTEST_F(NodeExtenedTest, NodeExtenedTest026, TestSize.Level1)
491 {
492     int32_t ret = LayoutNode(nullptr, 0, 0);
493     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
494     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
495     ASSERT_NE(nodeHandle, nullptr);
496     ret = LayoutNode(nodeHandle, 0, 0);
497     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
498     DisposeNode(nodeHandle);
499     nodeHandle = nullptr;
500 }
501 
502 /**
503  * @tc.name: NodeExtenedTest027
504  * @tc.desc: Test GetTotalChildCount function.
505  * @tc.type: FUNC
506  */
507 HWTEST_F(NodeExtenedTest, NodeExtenedTest027, TestSize.Level1)
508 {
509     int32_t ret = GetTotalChildCount(nullptr);
510     ASSERT_EQ(ret, 0);
511     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
512     ASSERT_NE(nodeHandle, nullptr);
513     ret = GetTotalChildCount(nodeHandle);
514     ASSERT_EQ(ret, 0);
515     DisposeNode(nodeHandle);
516     nodeHandle = nullptr;
517 }
518 
519 /**
520  * @tc.name: NodeExtenedTest028
521  * @tc.desc: Test GetChildAt function.
522  * @tc.type: FUNC
523  */
524 HWTEST_F(NodeExtenedTest, NodeExtenedTest028, TestSize.Level1)
525 {
526     ArkUI_NodeHandle node = GetChildAt(nullptr, 0);
527     ASSERT_EQ(node, nullptr);
528     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
529     ASSERT_NE(nodeHandle, nullptr);
530     node = GetChildAt(nodeHandle, 0);
531     ASSERT_EQ(node, nullptr);
532     DisposeNode(nodeHandle);
533     nodeHandle = nullptr;
534 }
535 
536 /**
537  * @tc.name: NodeExtenedTest029
538  * @tc.desc: Test GetFirstChild function.
539  * @tc.type: FUNC
540  */
541 HWTEST_F(NodeExtenedTest, NodeExtenedTest029, TestSize.Level1)
542 {
543     ArkUI_NodeHandle node = GetFirstChild(nullptr);
544     ASSERT_EQ(node, nullptr);
545     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
546     ASSERT_NE(nodeHandle, nullptr);
547     node = GetFirstChild(nodeHandle);
548     ASSERT_EQ(node, nullptr);
549     DisposeNode(nodeHandle);
550     nodeHandle = nullptr;
551 }
552 
553 /**
554  * @tc.name: NodeExtenedTest030
555  * @tc.desc: Test GetLastChild function.
556  * @tc.type: FUNC
557  */
558 HWTEST_F(NodeExtenedTest, NodeExtenedTest030, TestSize.Level1)
559 {
560     ArkUI_NodeHandle node = GetLastChild(nullptr);
561     ASSERT_EQ(node, nullptr);
562     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
563     ASSERT_NE(nodeHandle, nullptr);
564     node = GetLastChild(nodeHandle);
565     ASSERT_EQ(node, nullptr);
566     DisposeNode(nodeHandle);
567     nodeHandle = nullptr;
568 }
569 
570 /**
571  * @tc.name: NodeExtenedTest031
572  * @tc.desc: Test GetNextSibling function.
573  * @tc.type: FUNC
574  */
575 HWTEST_F(NodeExtenedTest, NodeExtenedTest031, TestSize.Level1)
576 {
577     ArkUI_NodeHandle node = GetNextSibling(nullptr);
578     ASSERT_EQ(node, nullptr);
579     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
580     ASSERT_NE(nodeHandle, nullptr);
581     node = GetNextSibling(nodeHandle);
582     ASSERT_EQ(node, nullptr);
583     DisposeNode(nodeHandle);
584     nodeHandle = nullptr;
585 }
586 
587 /**
588  * @tc.name: NodeExtenedTest032
589  * @tc.desc: Test GetParent function.
590  * @tc.type: FUNC
591  */
592 HWTEST_F(NodeExtenedTest, NodeExtenedTest032, TestSize.Level1)
593 {
594     ArkUI_NodeHandle node = GetParent(nullptr);
595     ASSERT_EQ(node, nullptr);
596     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
597     ASSERT_NE(nodeHandle, nullptr);
598     node = GetParent(nodeHandle);
599     ASSERT_EQ(node, nullptr);
600     DisposeNode(nodeHandle);
601     nodeHandle = nullptr;
602 }
603 
604 /**
605  * @tc.name: NodeExtenedTest033
606  * @tc.desc: Test GetParent function.
607  * @tc.type: FUNC
608  */
609 HWTEST_F(NodeExtenedTest, NodeExtenedTest033, TestSize.Level1)
610 {
611     ArkUI_NodeHandle nodeHandle = CreateNode(ArkUI_NodeType::ARKUI_NODE_SWIPER);
612     ASSERT_NE(nodeHandle, nullptr);
613     int32_t ret = RemoveAllChildren(nodeHandle);
614     ASSERT_EQ(ret, OHOS::Ace::ERROR_CODE_NO_ERROR);
615     DisposeNode(nodeHandle);
616     nodeHandle = nullptr;
617 }