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
27using namespace testing;
28using namespace testing::ext;
29using namespace OHOS::Ace::NodeModel;
30
31class NodeExtenedTest : public testing::Test {
32public:
33    static void SetUpTestCase()
34    {
35        InitialFullImpl();
36    };
37    static void TearDownTestCase() {};
38};
39
40void EventReceiverHandle(ArkUI_NodeCustomEvent* event) {}
41/**
42 * @tc.name: NodeExtenedTest001
43 * @tc.desc: Test NodeAddExtraData function.
44 * @tc.type: FUNC
45 */
46HWTEST_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 */
63HWTEST_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 */
76HWTEST_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 */
94HWTEST_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 */
113HWTEST_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 */
133HWTEST_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 */
152HWTEST_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 */
172HWTEST_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 */
192HWTEST_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 */
212HWTEST_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 */
232HWTEST_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 */
251HWTEST_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 */
269HWTEST_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 */
290HWTEST_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 */
310HWTEST_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 */
337HWTEST_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 */
363HWTEST_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 */
376HWTEST_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 */
387HWTEST_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 */
402HWTEST_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 */
418HWTEST_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 */
429HWTEST_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 */
445HWTEST_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 */
463HWTEST_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 */
474HWTEST_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 */
490HWTEST_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 */
507HWTEST_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 */
524HWTEST_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 */
541HWTEST_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 */
558HWTEST_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 */
575HWTEST_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 */
592HWTEST_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 */
609HWTEST_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}