• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <cstddef>
17 #include <cstdint>
18 #include "gtest/gtest.h"
19 #define private public
20 #define protected public
21 #include "native_interface.h"
22 #include "native_node.h"
23 #include "native_type.h"
24 #include "native_styled_string.h"
25 #include "event_converter.h"
26 #include "interfaces/native/node/node_model.h"
27 #include "test/mock/base/mock_task_executor.h"
28 #include "test/mock/core/common/mock_container.h"
29 #include "test/mock/core/common/mock_theme_manager.h"
30 #include "test/mock/core/pipeline/mock_pipeline_context.h"
31 #include "frameworks/base/error/error_code.h"
32 
33 using namespace testing;
34 using namespace testing::ext;
35 namespace OHOS::Ace {
36 class NativeNodeTest : public testing::Test {
37 public:
SetUpTestSuite()38     static void SetUpTestSuite()
39     {
40         NG::MockPipelineContext::SetUp();
41         MockContainer::SetUp();
42         MockContainer::Current()->pipelineContext_ = NG::MockPipelineContext::GetCurrent();
43         MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
44         MockContainer::Current()->pipelineContext_->taskExecutor_ = MockContainer::Current()->taskExecutor_;
45         auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
46         PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
47     }
TearDownTestSuite()48     static void TearDownTestSuite()
49     {
50         NG::MockPipelineContext::TearDown();
51         MockContainer::TearDown();
52     }
SetUp()53     void SetUp() {}
TearDown()54     void TearDown() {}
55 };
56 
57 /**
58  * @tc.name: NativeNodeTest001
59  * @tc.desc: Test OH_ArkUI_NodeEvent_GetEventType function.
60  * @tc.type: FUNC
61  */
62 HWTEST_F(NativeNodeTest, NativeNodeTest001, TestSize.Level1)
63 {
64     ArkUI_NodeEvent event = { 0, -1 };
65     auto eventType = OH_ArkUI_NodeEvent_GetEventType(&event);
66     EXPECT_EQ(eventType, ArkUI_NodeEventType::NODE_TOUCH_EVENT);
67     event.kind = 0;
68     EXPECT_EQ(OH_ArkUI_NodeEvent_GetEventType(&event), ArkUI_NodeEventType::NODE_TOUCH_EVENT);
69 }
70 
71 /**
72  * @tc.name: NativeNodeTest002
73  * @tc.desc: Test OH_ArkUI_NodeEvent_GetEventType function.
74  * @tc.type: FUNC
75  */
76 HWTEST_F(NativeNodeTest, NativeNodeTest002, TestSize.Level1)
77 {
78     auto eventType = OH_ArkUI_NodeEvent_GetEventType(nullptr);
79     EXPECT_EQ(eventType, ArkUI_NodeEventType::NODE_TOUCH_EVENT);
80 }
81 
82 /**
83  * @tc.name: NativeNodeTest003
84  * @tc.desc: Test OH_ArkUI_NodeEvent_GetTargetId function.
85  * @tc.type: FUNC
86  */
87 HWTEST_F(NativeNodeTest, NativeNodeTest003, TestSize.Level1)
88 {
89     auto targetId = OH_ArkUI_NodeEvent_GetTargetId(nullptr);
90     EXPECT_EQ(targetId, -1);
91     ArkUI_NodeEvent event = { 0, 0 };
92     event.eventId = 0;
93     EXPECT_EQ(OH_ArkUI_NodeEvent_GetTargetId(&event), 0);
94 }
95 
96 /**
97  * @tc.name: NativeNodeTest004
98  * @tc.desc: Test OH_ArkUI_NodeEvent_GetNodeHandle function.
99  * @tc.type: FUNC
100  */
101 HWTEST_F(NativeNodeTest, NativeNodeTest004, TestSize.Level1)
102 {
103     auto handle = OH_ArkUI_NodeEvent_GetNodeHandle(nullptr);
104     EXPECT_EQ(handle, nullptr);
105     ArkUI_NodeEvent event = { 0, 0 };
106     event.node = nullptr;
107     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNodeHandle(&event), nullptr);
108 }
109 
110 /**
111  * @tc.name: NativeNodeTest005
112  * @tc.desc: Test customNode function.
113  * @tc.type: FUNC
114  */
115 HWTEST_F(NativeNodeTest, NativeNodeTest005, TestSize.Level1)
116 {
117     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
118         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
119     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
120     auto childNode = nodeAPI->createNode(ARKUI_NODE_STACK);
121     ASSERT_NE(rootNode, nullptr);
122     int32_t ret1 = nodeAPI->addChild(rootNode, childNode);
123     EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR);
124     float size = 100.0f;
125     float padding = 10.0f;
126     float val0 = 0.0f;
127     float val01 = 0.1f;
128     float val05 = 0.5f;
129     float val1 = 1.0f;
130     float val10 = 10.0f;
131     float val100 = 100.0f;
132     float negativeFloat = -1.0f;
133     uint32_t color = 0xFFFF0000;
134     const char* pathCommands = "M100 0 L200 240 L0 240 Z";
135 
136     ArkUI_NumberValue value[] = {{.f32 = size}};
137     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
138     ArkUI_NumberValue value2[] = {{.f32 = val1}, {.f32 = val1}};
139     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
140     ArkUI_NumberValue value3[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0}};
141     ArkUI_AttributeItem item3 = {value3, sizeof(value3) / sizeof(ArkUI_NumberValue)};
142     ArkUI_NumberValue value4[] = {{.f32 = padding}, {.f32 = padding}, {.f32 = padding}, {.f32 = padding}};
143     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue)};
144     ArkUI_NumberValue value5[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0}, {.f32 = val0}, {.f32 = val0}};
145     ArkUI_AttributeItem item5 = {value5, sizeof(value5) / sizeof(ArkUI_NumberValue)};
146     nodeAPI->setAttribute(rootNode, NODE_WIDTH, &item);
147     auto widthVal = nodeAPI->getAttribute(rootNode, NODE_WIDTH);
148     EXPECT_EQ(widthVal->value[0].f32, size);
149 
150     nodeAPI->setAttribute(rootNode, NODE_HEIGHT, &item);
151     auto heightVal = nodeAPI->getAttribute(rootNode, NODE_HEIGHT);
152     EXPECT_EQ(heightVal->value[0].f32, size);
153 
154     value[0].u32 = color;
155     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_COLOR, &item);
156     auto colorVal = nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_COLOR);
157     EXPECT_EQ(colorVal->value[0].u32, color);
158 
159     item.string = "test";
160     value[0].i32 = ARKUI_IMAGE_REPEAT_X;
161     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE, &item);
162     nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_IMAGE);
163 
164     value[0].f32 = padding;
165     nodeAPI->setAttribute(rootNode, NODE_PADDING, &item);
166     auto paddingVal = nodeAPI->getAttribute(rootNode, NODE_PADDING);
167     EXPECT_EQ(paddingVal->value[0].f32, padding);
168     nodeAPI->setAttribute(rootNode, NODE_PADDING, &item4);
169     auto paddingVal4 = nodeAPI->getAttribute(rootNode, NODE_PADDING);
170     EXPECT_EQ(paddingVal4->value[0].f32, padding);
171 
172     nodeAPI->setAttribute(rootNode, NODE_MARGIN, &item);
173     auto marginVal = nodeAPI->getAttribute(rootNode, NODE_MARGIN);
174     EXPECT_EQ(marginVal->value[0].f32, padding);
175     nodeAPI->setAttribute(rootNode, NODE_MARGIN, &item4);
176     auto marginVal4 = nodeAPI->getAttribute(rootNode, NODE_MARGIN);
177     EXPECT_EQ(marginVal4->value[0].f32, padding);
178 
179     item.string = "test";
180     ret1 = nodeAPI->setAttribute(rootNode, NODE_ID, &item);
181     EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR);
182     auto keyVal = nodeAPI->getAttribute(rootNode, NODE_ID);
183     EXPECT_NE(keyVal, nullptr);
184 
185     value[0].i32 = true;
186     nodeAPI->setAttribute(rootNode, NODE_ENABLED, &item);
187     auto enableVal = nodeAPI->getAttribute(rootNode, NODE_ENABLED);
188     EXPECT_EQ(enableVal->value[0].i32, 1);
189 
190     nodeAPI->setAttribute(rootNode, NODE_TRANSLATE, &item3);
191     auto translateVal = nodeAPI->getAttribute(rootNode, NODE_TRANSLATE);
192     EXPECT_EQ(translateVal->value[0].f32, val0);
193 
194     nodeAPI->setAttribute(rootNode, NODE_SCALE, &item2);
195     auto scaleVal = nodeAPI->getAttribute(rootNode, NODE_SCALE);
196     EXPECT_EQ(scaleVal->value[0].f32, val1);
197     nodeAPI->setAttribute(rootNode, NODE_SCALE, &item5);
198 
199     nodeAPI->setAttribute(rootNode, NODE_ROTATE, &item5);
200     auto rotateVal = nodeAPI->getAttribute(rootNode, NODE_ROTATE);
201     EXPECT_EQ(rotateVal->value[0].f32, val0);
202 
203     value[0].f32 = val0;
204     nodeAPI->setAttribute(rootNode, NODE_BLUR, &item);
205     auto blurVal = nodeAPI->getAttribute(rootNode, NODE_BLUR);
206     EXPECT_EQ(blurVal->value[0].f32, val0);
207 
208     value[0].f32 = val0;
209     nodeAPI->setAttribute(rootNode, NODE_SATURATION, &item);
210     auto saturationVal = nodeAPI->getAttribute(rootNode, NODE_SATURATION);
211     EXPECT_EQ(saturationVal->value[0].f32, val0);
212 
213     value[0].f32 = val0;
214     nodeAPI->setAttribute(rootNode, NODE_BRIGHTNESS, &item);
215     auto brightnessVal = nodeAPI->getAttribute(rootNode, NODE_BRIGHTNESS);
216     EXPECT_EQ(brightnessVal->value[0].f32, val0);
217 
218     value3[0].f32 = val0;
219     value3[1].i32 = ARKUI_LINEAR_GRADIENT_DIRECTION_LEFT;
220     value3[2].i32 = false;
221     uint32_t colors[] = {color, color};
222     float stops[] = {val0, val05};
223     ArkUI_ColorStop colorStop = {colors, stops, 2};
224     ArkUI_ColorStop* colorStopPtr = &colorStop;
225     item3.object = reinterpret_cast<void*>(colorStopPtr);
226     nodeAPI->setAttribute(rootNode, NODE_LINEAR_GRADIENT, &item3);
227     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LINEAR_GRADIENT), nullptr);
228 
229     ArkUI_NumberValue sweepGradient[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0}, {.f32 = val0}, {.f32 = val0},
230         {.i32 = true}};
231     ArkUI_AttributeItem sweepGradientItem = {sweepGradient, sizeof(sweepGradient) / sizeof(ArkUI_NumberValue)};
232     sweepGradientItem.object = reinterpret_cast<void*>(colorStopPtr);
233     sweepGradientItem.size = -1;
234     nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &sweepGradientItem);
235     sweepGradientItem.size = 1;
236     nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &sweepGradientItem);
237     sweepGradientItem.size = 2;
238     nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &sweepGradientItem);
239     sweepGradientItem.size = 3;
240     nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &sweepGradientItem);
241     sweepGradientItem.size = 4;
242     nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &sweepGradientItem);
243     sweepGradientItem.size = sizeof(sweepGradient) / sizeof(ArkUI_NumberValue);
244     nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &sweepGradientItem);
245     auto sweepGradientVal = nodeAPI->getAttribute(rootNode, NODE_SWEEP_GRADIENT);
246     EXPECT_EQ(sweepGradientVal->value[0].f32, val0);
247 
248     ArkUI_NumberValue radialGradient[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0}, {.i32 = true}};
249     ArkUI_AttributeItem radialGradientItem = {radialGradient, sizeof(radialGradient) / sizeof(ArkUI_NumberValue)};
250     radialGradientItem.object = reinterpret_cast<void*>(colorStopPtr);
251     radialGradientItem.size = -1;
252     nodeAPI->setAttribute(rootNode, NODE_RADIAL_GRADIENT, &radialGradientItem);
253     radialGradientItem.size = 1;
254     nodeAPI->setAttribute(rootNode, NODE_RADIAL_GRADIENT, &radialGradientItem);
255     radialGradientItem.size = 2;
256     nodeAPI->setAttribute(rootNode, NODE_RADIAL_GRADIENT, &radialGradientItem);
257     radialGradientItem.size = sizeof(radialGradient) / sizeof(ArkUI_NumberValue);
258     nodeAPI->setAttribute(rootNode, NODE_RADIAL_GRADIENT, &radialGradientItem);
259     auto radialGradientVal = nodeAPI->getAttribute(rootNode, NODE_RADIAL_GRADIENT);
260     EXPECT_EQ(radialGradientVal->value[0].f32, val0);
261 
262     value[0].i32 = ARKUI_ALIGNMENT_CENTER;
263     nodeAPI->setAttribute(rootNode, NODE_ALIGNMENT, &item);
264     auto alignVal = nodeAPI->getAttribute(rootNode, NODE_ALIGNMENT);
265     EXPECT_EQ(alignVal->value[0].i32, static_cast<int32_t>(ARKUI_ALIGNMENT_CENTER));
266 
267     value[0].f32 = val0;
268     nodeAPI->setAttribute(rootNode, NODE_OPACITY, &item);
269     auto opacityVal = nodeAPI->getAttribute(rootNode, NODE_OPACITY);
270     EXPECT_EQ(opacityVal->value[0].f32, val0);
271 
272     value[0].f32 = val10;
273     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item);
274     auto borderWidthVal = nodeAPI->getAttribute(rootNode, NODE_BORDER_WIDTH);
275     EXPECT_EQ(borderWidthVal->value[0].f32, val10);
276     value4[0].f32 = val10;
277     value4[1].f32 = val10;
278     value4[2].f32 = val10;
279     value4[3].f32 = val10;
280     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item4);
281     auto borderWidthVal4 = nodeAPI->getAttribute(rootNode, NODE_BORDER_WIDTH);
282     EXPECT_EQ(borderWidthVal4->value[0].f32, val10);
283 
284     value[0].f32 = val01;
285     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item);
286     borderWidthVal = nodeAPI->getAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT);
287     EXPECT_EQ(borderWidthVal->value[0].f32, val01);
288     value4[0].f32 = val01;
289     value4[1].f32 = val01;
290     value4[2].f32 = val01;
291     value4[3].f32 = val01;
292     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item4);
293     borderWidthVal4 = nodeAPI->getAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT);
294     EXPECT_EQ(borderWidthVal4->value[0].f32, val01);
295 
296     value[0].f32 = val10;
297     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item);
298     auto borderRadiusVal = nodeAPI->getAttribute(rootNode, NODE_BORDER_RADIUS);
299     EXPECT_EQ(borderRadiusVal->value[0].f32, val10);
300     value4[0].f32 = val10;
301     value4[1].f32 = val10;
302     value4[2].f32 = val10;
303     value4[3].f32 = val10;
304     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item4);
305     auto borderRadiusVal4 = nodeAPI->getAttribute(rootNode, NODE_BORDER_RADIUS);
306     EXPECT_EQ(borderRadiusVal4->value[0].f32, val10);
307     value[0].f32 = val01;
308     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item);
309     borderRadiusVal = nodeAPI->getAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT);
310     EXPECT_EQ(borderRadiusVal->value[0].f32, val01);
311     value4[0].f32 = val01;
312     value4[1].f32 = val01;
313     value4[2].f32 = val01;
314     value4[3].f32 = val01;
315     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item4);
316     borderRadiusVal4 = nodeAPI->getAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT);
317     EXPECT_EQ(borderRadiusVal4->value[0].f32, val01);
318 
319     value[0].u32 = color;
320     nodeAPI->setAttribute(rootNode, NODE_BORDER_COLOR, &item);
321     auto borderColorVal = nodeAPI->getAttribute(rootNode, NODE_BORDER_COLOR);
322     EXPECT_EQ(borderColorVal->value[0].u32, color);
323     value4[0].u32 = color;
324     value4[1].u32 = color;
325     value4[2].u32 = color;
326     value4[3].u32 = color;
327     nodeAPI->setAttribute(rootNode, NODE_BORDER_COLOR, &item4);
328     auto borderColorVal4 = nodeAPI->getAttribute(rootNode, NODE_BORDER_COLOR);
329     EXPECT_EQ(borderColorVal4->value[0].u32, color);
330 
331     value[0].i32 = ARKUI_BORDER_STYLE_SOLID;
332     nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &item);
333     auto borderStyleVal = nodeAPI->getAttribute(rootNode, NODE_BORDER_STYLE);
334     EXPECT_EQ(borderStyleVal->value[0].i32, static_cast<int32_t>(ARKUI_BORDER_STYLE_SOLID));
335     value4[0].i32 = ARKUI_BORDER_STYLE_SOLID;
336     value4[1].i32 = ARKUI_BORDER_STYLE_SOLID;
337     value4[2].i32 = ARKUI_BORDER_STYLE_SOLID;
338     value4[3].i32 = ARKUI_BORDER_STYLE_SOLID;
339     nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &item4);
340     auto borderStyleVal4 = nodeAPI->getAttribute(rootNode, NODE_BORDER_STYLE);
341     EXPECT_EQ(borderStyleVal4->value[0].i32, ARKUI_BORDER_STYLE_SOLID);
342 
343     value[0].f32 = val1;
344     nodeAPI->setAttribute(rootNode, NODE_Z_INDEX, &item);
345     auto zIndexVal = nodeAPI->getAttribute(rootNode, NODE_Z_INDEX);
346     EXPECT_EQ(zIndexVal->value[0].f32, val1);
347 
348     value[0].i32 = ARKUI_VISIBILITY_VISIBLE;
349     nodeAPI->setAttribute(rootNode, NODE_VISIBILITY, &item);
350     auto visibilityVal = nodeAPI->getAttribute(rootNode, NODE_VISIBILITY);
351     EXPECT_EQ(visibilityVal->value[0].i32, static_cast<int32_t>(ARKUI_VISIBILITY_VISIBLE));
352 
353     value[0].i32 = true;
354     nodeAPI->setAttribute(rootNode, NODE_CLIP, &item);
355     auto clipVal = nodeAPI->getAttribute(rootNode, NODE_CLIP);
356     EXPECT_EQ(clipVal->value[0].i32, true);
357 
358     value5[0].i32 = ARKUI_CLIP_TYPE_RECTANGLE;
359     value5[1].f32 = size;
360     value5[2].f32 = size;
361     value5[3].f32 = val10;
362     value5[4].f32 = val10;
363     nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item5);
364     auto clipShapeVal = nodeAPI->getAttribute(rootNode, NODE_CLIP_SHAPE);
365     EXPECT_EQ(clipShapeVal->value[0].i32, ARKUI_CLIP_TYPE_RECTANGLE);
366     value3[0].i32 = ARKUI_CLIP_TYPE_CIRCLE;
367     value3[1].f32 = size;
368     value3[2].f32 = size;
369     nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item3);
370     clipShapeVal = nodeAPI->getAttribute(rootNode, NODE_CLIP_SHAPE);
371     EXPECT_EQ(clipShapeVal->value[0].i32, ARKUI_CLIP_TYPE_CIRCLE);
372     value3[0].i32 = ARKUI_CLIP_TYPE_ELLIPSE;
373     value3[1].f32 = size;
374     value3[2].f32 = size;
375     nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item3);
376     clipShapeVal = nodeAPI->getAttribute(rootNode, NODE_CLIP_SHAPE);
377     EXPECT_EQ(clipShapeVal->value[0].i32, ARKUI_CLIP_TYPE_ELLIPSE);
378     value3[1].f32 = negativeFloat;
379     nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item3);
380 
381     value3[0].i32 = ARKUI_CLIP_TYPE_PATH;
382     value3[1].f32 = size;
383     value3[2].f32 = size;
384     item3.string = nullptr;
385     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item3), ARKUI_ERROR_CODE_PARAM_INVALID);
386     item3.string = pathCommands;
387     nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item3);
388     clipShapeVal = nodeAPI->getAttribute(rootNode, NODE_CLIP_SHAPE);
389     EXPECT_EQ(clipShapeVal->value[0].i32, ARKUI_CLIP_TYPE_PATH);
390     value3[2].f32 = negativeFloat;
391     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item3), ARKUI_ERROR_CODE_PARAM_INVALID);
392     value3[1].f32 = negativeFloat;
393     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item3), ARKUI_ERROR_CODE_PARAM_INVALID);
394 
395     ArkUI_NumberValue transformVal[] =
396         {{.f32 = val1}, {.f32 = val0}, {.f32 = val0}, {.f32 = val0},
397         {.f32 = val0}, {.f32 = val1}, {.f32 = val0}, {.f32 = val0},
398         {.f32 = val0}, {.f32 = val0}, {.f32 = val1}, {.f32 = val0},
399         {.f32 = val0}, {.f32 = val0}, {.f32 = val0}, {.f32 = val1}};
400     ArkUI_AttributeItem transformItem = {transformVal, sizeof(transformVal) / sizeof(ArkUI_NumberValue)};
401     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM, &transformItem);
402     auto transformResult = nodeAPI->getAttribute(rootNode, NODE_TRANSFORM);
403     EXPECT_EQ(transformResult->value[0].f32, val1);
404 
405     value[0].i32 = ARKUI_HIT_TEST_MODE_DEFAULT;
406     nodeAPI->setAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR, &item);
407     auto hitVal = nodeAPI->getAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR);
408     EXPECT_EQ(hitVal->value[0].i32, static_cast<int32_t>(ARKUI_HIT_TEST_MODE_DEFAULT));
409 
410     value2[0].f32 = val10;
411     value2[1].f32 = val10;
412     nodeAPI->setAttribute(rootNode, NODE_POSITION, &item2);
413     auto positionVal = nodeAPI->getAttribute(rootNode, NODE_POSITION);
414     EXPECT_EQ(positionVal->value[0].f32, val10);
415 
416     value[0].i32 = ARKUI_SHADOW_STYLE_OUTER_DEFAULT_MD;
417     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SHADOW, &item), ARKUI_ERROR_CODE_NO_ERROR);
418     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SHADOW), nullptr);
419 
420 
421     ArkUI_NumberValue customShadowVal[] = {{.f32 = val10}, {.i32 = false}, {.f32 = val0}, {.f32 = val0},
422         {.i32 = ARKUI_SHADOW_TYPE_COLOR}, {.u32 = color}, {.u32 = 1}};
423     ArkUI_AttributeItem customShadowItem = {customShadowVal, sizeof(customShadowVal) / sizeof(ArkUI_NumberValue)};
424     nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem);
425     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CUSTOM_SHADOW), nullptr);
426     customShadowItem.size = 1;
427     nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem);
428     customShadowItem.size = 2;
429     nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem);
430     customShadowItem.size = 3;
431     nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem);
432     customShadowItem.size = 4;
433     nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem);
434     customShadowItem.size = 5;
435     nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem);
436     customShadowVal[4].i32 = -1;
437     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem), ARKUI_ERROR_CODE_PARAM_INVALID);
438     customShadowItem.size = 6;
439     customShadowVal[4].i32 = ARKUI_SHADOW_TYPE_COLOR;
440     nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem);
441     customShadowVal[1].i32 = true;
442     customShadowVal[5].i32 = -1;
443     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem), ARKUI_ERROR_CODE_PARAM_INVALID);
444     customShadowVal[5].i32 = 0;
445     nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &customShadowItem);
446 
447 
448     value2[0].f32 = size;
449     value2[1].f32 = size;
450     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE, &item2);
451     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE), nullptr);
452 
453     value[0].i32 = ARKUI_IMAGE_SIZE_COVER;
454     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE, &item);
455     auto imagesizeStyleVal = nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE);
456     EXPECT_EQ(imagesizeStyleVal->value[0].i32, static_cast<int32_t>(ARKUI_IMAGE_SIZE_COVER));
457     value[0].i32 = ARKUI_IMAGE_SIZE_AUTO;
458     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE, &item);
459     value[0].i32 = ARKUI_IMAGE_SIZE_CONTAIN;
460     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE, &item);
461 
462     ArkUI_NumberValue backgroundBlurVal[] = {{.i32 = ARKUI_BLUR_STYLE_THIN}, {.i32 = ARKUI_COLOR_MODE_SYSTEM},
463         {.i32 = ARKUI_ADAPTIVE_COLOR_DEFAULT}, {.f32 = val05}, {.f32 = val0}, {.f32 = val0}};
464     ArkUI_AttributeItem backgroundBlurItem = {backgroundBlurVal, sizeof(backgroundBlurVal) / sizeof(ArkUI_NumberValue)};
465     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem);
466     auto backgroundBlurResult = nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE);
467     EXPECT_NE(backgroundBlurResult, nullptr);
468     nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_BLUR_STYLE, &backgroundBlurItem);
469     auto foregroundBlurStyleVal = nodeAPI->getAttribute(rootNode, NODE_FOREGROUND_BLUR_STYLE);
470     EXPECT_NE(foregroundBlurStyleVal, nullptr);
471     backgroundBlurVal[0].i32 = ARKUI_BLUR_STYLE_NONE;
472     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem);
473     nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE);
474     backgroundBlurVal[0].i32 = ARKUI_BLUR_STYLE_COMPONENT_ULTRA_THIN;
475     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem);
476     nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE);
477     backgroundBlurItem.size = 1;
478     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem);
479     nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_BLUR_STYLE, &backgroundBlurItem);
480 
481 
482     ArkUI_NumberValue transformCenter[] = {{.f32 = val0}, {.i32 = val0}, {.f32 = val0}, {.f32 = val05},
483         {.f32 = val05}, {.f32 = val0}};
484     ArkUI_AttributeItem transformCenterItem = {transformCenter, sizeof(transformCenter) / sizeof(ArkUI_NumberValue)};
485     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &transformCenterItem);
486     auto transformCenterVal = nodeAPI->getAttribute(rootNode, NODE_TRANSFORM_CENTER);
487     EXPECT_EQ(transformCenterVal->value[0].f32, val0);
488     transformCenterItem.size = 0;
489     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &transformCenterItem);
490     transformCenterItem.size = sizeof(transformCenter) / sizeof(ArkUI_NumberValue);
491     transformCenter[5].f32 = -1.0f;
492     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &transformCenterItem);
493     transformCenter[5].f32 = 2.0f;
494     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &transformCenterItem);
495     transformCenter[4].f32 = -1.0f;
496     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &transformCenterItem);
497     transformCenter[4].f32 = 2.0f;
498     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &transformCenterItem);
499     transformCenter[3].f32 = -1.0f;
500     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &transformCenterItem);
501     transformCenter[3].f32 = 2.0f;
502     nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &transformCenterItem);
503 
504     ArkUI_NumberValue opacityTransition[] = {{.f32 = val0}, {.i32 = 1000}, {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = 1000},
505         {.i32 = 1}, {.i32 = ARKUI_ANIMATION_PLAY_MODE_NORMAL}, {.f32 = val1}};
506     ArkUI_AttributeItem opacityTransitionItem =
507         {opacityTransition, sizeof(opacityTransition) / sizeof(ArkUI_NumberValue)};
508     nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem);
509     auto opacityTransitionVal = nodeAPI->getAttribute(rootNode, NODE_OPACITY_TRANSITION);
510     EXPECT_EQ(opacityTransitionVal->value[0].f32, val0);
511     opacityTransition[5].i32 = ARKUI_ANIMATION_PLAY_MODE_REVERSE;
512     nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem);
513     nodeAPI->getAttribute(rootNode, NODE_OPACITY_TRANSITION);
514     opacityTransition[5].i32 = ARKUI_ANIMATION_PLAY_MODE_ALTERNATE;
515     nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem);
516     nodeAPI->getAttribute(rootNode, NODE_OPACITY_TRANSITION);
517 
518     ArkUI_NumberValue rotateTransition[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0}, {.f32 = val10},
519         {.f32 = val0}, {.i32 = 1000}, {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = 1000},
520         {.i32 = 1}, {.i32 = ARKUI_ANIMATION_PLAY_MODE_NORMAL}, {.f32 = val1}};
521     ArkUI_AttributeItem rotateTransitionItem =
522         {rotateTransition, sizeof(rotateTransition) / sizeof(ArkUI_NumberValue)};
523     nodeAPI->setAttribute(rootNode, NODE_ROTATE_TRANSITION, &rotateTransitionItem);
524     auto rotateTransitionVal = nodeAPI->getAttribute(rootNode, NODE_ROTATE_TRANSITION);
525     EXPECT_EQ(rotateTransitionVal->value[0].f32, val0);
526     rotateTransition[6].i32 = -1;
527     nodeAPI->setAttribute(rootNode, NODE_ROTATE_TRANSITION, &rotateTransitionItem);
528 
529     ArkUI_NumberValue scaleTransition[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0},
530         {.i32 = 1000}, {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = 1000},
531         {.i32 = 1}, {.i32 = ARKUI_ANIMATION_PLAY_MODE_NORMAL}, {.f32 = val1}};
532     ArkUI_AttributeItem scaleTransitionItem =
533         {scaleTransition, sizeof(scaleTransition) / sizeof(ArkUI_NumberValue)};
534     nodeAPI->setAttribute(rootNode, NODE_SCALE_TRANSITION, &scaleTransitionItem);
535     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCALE_TRANSITION), nullptr);
536     scaleTransition[4].i32 = -1;
537     nodeAPI->setAttribute(rootNode, NODE_SCALE_TRANSITION, &scaleTransitionItem);
538 
539     ArkUI_NumberValue translateTransition[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0},
540         {.i32 = 1000}, {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = 1000},
541         {.i32 = 1}, {.i32 = ARKUI_ANIMATION_PLAY_MODE_NORMAL}, {.f32 = val1}};
542     ArkUI_AttributeItem translateTransitionItem =
543         {translateTransition, sizeof(translateTransition) / sizeof(ArkUI_NumberValue)};
544     nodeAPI->setAttribute(rootNode, NODE_TRANSLATE_TRANSITION, &translateTransitionItem);
545     auto translateTransitionVal = nodeAPI->getAttribute(rootNode, NODE_TRANSLATE_TRANSITION);
546     EXPECT_EQ(translateTransitionVal->value[0].f32, val0);
547     translateTransition[4].i32 = -1;
548     nodeAPI->setAttribute(rootNode, NODE_TRANSLATE_TRANSITION, &translateTransitionItem);
549 
550     ArkUI_NumberValue moveTransition[] = {{.i32 = ARKUI_TRANSITION_EDGE_TOP},
551         {.i32 = 1000}, {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = 1000},
552         {.i32 = 1}, {.i32 = ARKUI_ANIMATION_PLAY_MODE_NORMAL}, {.f32 = val1}};
553     ArkUI_AttributeItem moveTransitionItem =
554         {moveTransition, sizeof(moveTransition) / sizeof(ArkUI_NumberValue)};
555     nodeAPI->setAttribute(rootNode, NODE_MOVE_TRANSITION, &moveTransitionItem);
556     auto moveTransitionVal = nodeAPI->getAttribute(rootNode, NODE_MOVE_TRANSITION);
557     EXPECT_EQ(moveTransitionVal->value[0].i32, static_cast<int32_t>(ARKUI_TRANSITION_EDGE_TOP));
558     moveTransition[0].i32 = -1;
559     nodeAPI->setAttribute(rootNode, NODE_MOVE_TRANSITION, &moveTransitionItem);
560     moveTransition[0].i32 = ARKUI_TRANSITION_EDGE_TOP;
561     moveTransition[2].i32 = -1;
562     nodeAPI->setAttribute(rootNode, NODE_MOVE_TRANSITION, &moveTransitionItem);
563 
564     value[0].i32 = true;
565     nodeAPI->setAttribute(rootNode, NODE_FOCUSABLE, &item);
566     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FOCUSABLE), nullptr);
567 
568     value[0].i32 = true;
569     nodeAPI->setAttribute(rootNode, NODE_DEFAULT_FOCUS, &item);
570     auto defaultFocusVal = nodeAPI->getAttribute(rootNode, NODE_DEFAULT_FOCUS);
571     EXPECT_EQ(defaultFocusVal->value[0].i32, true);
572 
573     value4[0].f32 = val0;
574     value4[1].f32 = val0;
575     value4[2].f32 = val100;
576     value4[3].f32 = val100;
577     nodeAPI->setAttribute(rootNode, NODE_RESPONSE_REGION, &item4);
578     auto responseRegionVal = nodeAPI->getAttribute(rootNode, NODE_RESPONSE_REGION);
579     EXPECT_EQ(responseRegionVal->value[0].f32, val0);
580     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RESPONSE_REGION, &item5), ARKUI_ERROR_CODE_PARAM_INVALID);
581 
582     value3[0].i32 = ARKUI_ALIGNMENT_TOP_START;
583     value3[1].f32 = val0;
584     value3[2].f32 = val0;
585     item3.string = "test";
586     item3.size = 0;
587     nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &item3);
588     item3.size = 1;
589     nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &item3);
590     item3.size = 2;
591     nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &item3);
592     item3.size = 3;
593     nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &item3);
594     auto overlayVal = nodeAPI->getAttribute(rootNode, NODE_OVERLAY);
595     EXPECT_EQ(overlayVal->value[0].i32, static_cast<int32_t>(ARKUI_ALIGNMENT_TOP_START));
596 
597     ArkUI_NumberValue mask[] = {{.u32 = color}, {.u32 = color}, {.f32 = val10}, {.i32 = ARKUI_MASK_TYPE_RECTANGLE},
598         {.f32 = size}, {.f32 = size}, {.f32 = val10}, {.f32 = val10}};
599     ArkUI_AttributeItem maskItem = {mask, sizeof(mask) / sizeof(ArkUI_NumberValue)};
600     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_NO_ERROR);
601     auto maskVal = nodeAPI->getAttribute(rootNode, NODE_MASK);
602     EXPECT_NE(maskVal, nullptr);
603     mask[3].i32 = ARKUI_MASK_TYPE_CIRCLE;
604     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_NO_ERROR);
605     maskVal = nodeAPI->getAttribute(rootNode, NODE_MASK);
606     EXPECT_NE(maskVal, nullptr);
607     mask[3].i32 = ARKUI_MASK_TYPE_ELLIPSE;
608     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_NO_ERROR);
609     maskVal = nodeAPI->getAttribute(rootNode, NODE_MASK);
610     EXPECT_NE(maskVal, nullptr);
611     mask[3].i32 = ARKUI_MASK_TYPE_PATH;
612     maskItem.string = pathCommands;
613     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_NO_ERROR);
614     maskVal = nodeAPI->getAttribute(rootNode, NODE_MASK);
615     EXPECT_NE(maskVal, nullptr);
616     value4[0].i32 = ARKUI_MASK_TYPE_PROGRESS;
617     value4[1].f32 = val10;
618     value4[2].f32 = val100;
619     value4[3].u32 = color;
620     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &item4), ARKUI_ERROR_CODE_NO_ERROR);
621     maskVal = nodeAPI->getAttribute(rootNode, NODE_MASK);
622 
623     value2[0].i32 = ARKUI_BLEND_MODE_NONE;
624     value2[1].i32 = BLEND_APPLY_TYPE_FAST;
625     nodeAPI->setAttribute(rootNode, NODE_BLEND_MODE, &item2);
626     auto blendModeVal = nodeAPI->getAttribute(rootNode, NODE_BLEND_MODE);
627     EXPECT_EQ(blendModeVal->value[0].i32, static_cast<int32_t>(ARKUI_BLEND_MODE_NONE));
628 
629     value[0].i32 = ARKUI_DIRECTION_LTR;
630     nodeAPI->setAttribute(rootNode, NODE_DIRECTION, &item);
631     auto directionVal = nodeAPI->getAttribute(rootNode, NODE_DIRECTION);
632     EXPECT_EQ(directionVal->value[0].i32, static_cast<int32_t>(ARKUI_DIRECTION_LTR));
633 
634     value4[0].f32 = val0;
635     value4[1].f32 = size;
636     value4[2].f32 = val0;
637     value4[3].f32 = size;
638     nodeAPI->setAttribute(rootNode, NODE_CONSTRAINT_SIZE, &item4);
639     auto constraintSizeVal = nodeAPI->getAttribute(rootNode, NODE_CONSTRAINT_SIZE);
640     EXPECT_EQ(constraintSizeVal->value[0].f32, val0);
641 
642     value[0].f32 = val05;
643     nodeAPI->setAttribute(rootNode, NODE_GRAY_SCALE, &item);
644     auto grayScaleVal = nodeAPI->getAttribute(rootNode, NODE_GRAY_SCALE);
645     EXPECT_EQ(grayScaleVal->value[0].f32, val05);
646     value[0].f32 = val10;
647     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRAY_SCALE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
648 
649     value[0].f32 = val05;
650     nodeAPI->setAttribute(rootNode, NODE_INVERT, &item);
651     auto invertVal = nodeAPI->getAttribute(rootNode, NODE_INVERT);
652     EXPECT_EQ(invertVal->value[0].f32, val05);
653     value[0].f32 = val10;
654     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_INVERT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
655 
656     value[0].f32 = val05;
657     nodeAPI->setAttribute(rootNode, NODE_SEPIA, &item);
658     auto sepiaVal = nodeAPI->getAttribute(rootNode, NODE_SEPIA);
659     EXPECT_EQ(sepiaVal->value[0].f32, val05);
660     value[0].f32 = val10;
661     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SEPIA, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
662 
663     value[0].f32 = val05;
664     nodeAPI->setAttribute(rootNode, NODE_CONTRAST, &item);
665     auto contrastVal = nodeAPI->getAttribute(rootNode, NODE_CONTRAST);
666     EXPECT_EQ(contrastVal->value[0].f32, val05);
667     value[0].f32 = val100;
668     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONTRAST, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
669 
670     value[0].u32 = color;
671     nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_COLOR, &item);
672     auto foregroundColorVal = nodeAPI->getAttribute(rootNode, NODE_FOREGROUND_COLOR);
673     EXPECT_NE(foregroundColorVal, nullptr);
674     value[0].i32 = ARKUI_COLOR_STRATEGY_INVERT;
675     nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_COLOR, &item);
676     value[0].i32 = ARKUI_COLOR_STRATEGY_AVERAGE;
677     nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_COLOR, &item);
678     value[0].i32 = ARKUI_COLOR_STRATEGY_PRIMARY;
679     nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_COLOR, &item);
680 
681     value2[0].f32 = val10;
682     value2[1].f32 = val10;
683     nodeAPI->setAttribute(rootNode, NODE_OFFSET, &item2);
684     auto offsetVal = nodeAPI->getAttribute(rootNode, NODE_OFFSET);
685     EXPECT_EQ(offsetVal->value[0].f32, val10);
686 
687     value2[0].f32 = val10;
688     value2[1].f32 = val10;
689     nodeAPI->setAttribute(rootNode, NODE_MARK_ANCHOR, &item2);
690     auto maskAnchorVal = nodeAPI->getAttribute(rootNode, NODE_MARK_ANCHOR);
691     EXPECT_EQ(maskAnchorVal->value[0].f32, val10);
692 
693     value2[0].f32 = val10;
694     value2[1].f32 = val10;
695     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_POSITION, &item2);
696     auto backgroundImagePositionVal = nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_IMAGE_POSITION);
697     EXPECT_EQ(backgroundImagePositionVal->value[0].f32, val10);
698 
699     value[0].i32 = 0;
700     nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_GROUP, &item);
701     auto accessibilityGroupVal = nodeAPI->getAttribute(rootNode, NODE_ACCESSIBILITY_GROUP);
702     EXPECT_EQ(accessibilityGroupVal->value[0].i32, 0);
703 
704     item.string = "test";
705     nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_TEXT, &item);
706     auto accessibilityTextVal = nodeAPI->getAttribute(rootNode, NODE_ACCESSIBILITY_TEXT);
707     EXPECT_NE(accessibilityTextVal, nullptr);
708     nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_DESCRIPTION, &item);
709     auto accessibilityDescVal = nodeAPI->getAttribute(rootNode, NODE_ACCESSIBILITY_DESCRIPTION);
710     EXPECT_NE(accessibilityDescVal, nullptr);
711 
712     value[0].i32 = ARKUI_ACCESSIBILITY_MODE_AUTO;
713     nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_MODE, &item);
714     auto accessibilityModeVal = nodeAPI->getAttribute(rootNode, NODE_ACCESSIBILITY_MODE);
715     EXPECT_EQ(accessibilityModeVal->value[0].i32, static_cast<int32_t>(ARKUI_ACCESSIBILITY_MODE_AUTO));
716 
717     value[0].f32 = val05;
718     nodeAPI->setAttribute(rootNode, NODE_ASPECT_RATIO, &item);
719     auto aspectRatioVal = nodeAPI->getAttribute(rootNode, NODE_ASPECT_RATIO);
720     EXPECT_EQ(aspectRatioVal->value[0].f32, val05);
721 
722     value[0].f32 = val05;
723     nodeAPI->setAttribute(rootNode, NODE_LAYOUT_WEIGHT, &item);
724     auto layoutWeightVal = nodeAPI->getAttribute(rootNode, NODE_LAYOUT_WEIGHT);
725     EXPECT_EQ(layoutWeightVal->value[0].f32, val05);
726 
727     value[0].u32 = 0;
728     nodeAPI->setAttribute(rootNode, NODE_DISPLAY_PRIORITY, &item);
729     auto displayPriorityVal = nodeAPI->getAttribute(rootNode, NODE_DISPLAY_PRIORITY);
730     EXPECT_EQ(displayPriorityVal->value[0].u32, 0);
731 
732     value4[0].f32 = val10;
733     value4[1].f32 = val10;
734     value4[2].f32 = val10;
735     value4[3].f32 = val10;
736     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OUTLINE_WIDTH, &item4), ARKUI_ERROR_CODE_NO_ERROR);
737 
738     value[0].f32 = val05;
739     nodeAPI->setAttribute(rootNode, NODE_WIDTH_PERCENT, &item);
740     auto widthPercentVal = nodeAPI->getAttribute(rootNode, NODE_WIDTH_PERCENT);
741     EXPECT_EQ(widthPercentVal->value[0].f32, val05);
742 
743     value[0].f32 = val05;
744     nodeAPI->setAttribute(rootNode, NODE_HEIGHT_PERCENT, &item);
745     auto heightPercentVal = nodeAPI->getAttribute(rootNode, NODE_HEIGHT_PERCENT);
746     EXPECT_EQ(heightPercentVal->value[0].f32, val05);
747 
748     value[0].f32 = val01;
749     nodeAPI->setAttribute(rootNode, NODE_PADDING_PERCENT, &item);
750     auto paddingPercentVal = nodeAPI->getAttribute(rootNode, NODE_PADDING_PERCENT);
751     EXPECT_EQ(paddingPercentVal->value[0].f32, val01);
752     value4[0].f32 = val01;
753     value4[1].f32 = val01;
754     value4[2].f32 = val01;
755     value4[3].f32 = val01;
756     nodeAPI->setAttribute(rootNode, NODE_PADDING_PERCENT, &item4);
757     auto paddingPercentVal4 = nodeAPI->getAttribute(rootNode, NODE_PADDING_PERCENT);
758     EXPECT_EQ(paddingPercentVal4->value[0].f32, val01);
759 
760     nodeAPI->setAttribute(rootNode, NODE_MARGIN_PERCENT, &item);
761     auto marginPercentVal = nodeAPI->getAttribute(rootNode, NODE_MARGIN_PERCENT);
762     EXPECT_EQ(marginPercentVal->value[0].f32, val01);
763     nodeAPI->setAttribute(rootNode, NODE_MARGIN_PERCENT, &item4);
764     auto marginPercentVal4 = nodeAPI->getAttribute(rootNode, NODE_MARGIN_PERCENT);
765     EXPECT_EQ(marginPercentVal4->value[0].f32, val01);
766 
767     value[0].i32 = false;
768     item.string = "test";
769     item.size = 0;
770     nodeAPI->setAttribute(rootNode, NODE_GEOMETRY_TRANSITION, &item);
771     item.size = 1;
772     nodeAPI->setAttribute(rootNode, NODE_GEOMETRY_TRANSITION, &item);
773     auto geometryTransitionVal = nodeAPI->getAttribute(rootNode, NODE_GEOMETRY_TRANSITION);
774     EXPECT_EQ(geometryTransitionVal->value[0].i32, 0);
775 
776     value[0].i32 = ARKUI_RENDER_FIT_CENTER;
777     nodeAPI->setAttribute(rootNode, NODE_RENDER_FIT, &item);
778     auto renderFitVal = nodeAPI->getAttribute(rootNode, NODE_RENDER_FIT);
779     EXPECT_EQ(renderFitVal->value[0].i32, static_cast<int32_t>(ARKUI_RENDER_FIT_CENTER));
780 
781     value[0].u32 = color;
782     nodeAPI->setAttribute(rootNode, NODE_OUTLINE_COLOR, &item);
783     auto outlineColorVal = nodeAPI->getAttribute(rootNode, NODE_OUTLINE_COLOR);
784     EXPECT_EQ(outlineColorVal->value[0].u32, color);
785     value4[0].u32 = color;
786     value4[1].u32 = color;
787     value4[2].u32 = color;
788     value4[3].u32 = color;
789     nodeAPI->setAttribute(rootNode, NODE_OUTLINE_COLOR, &item4);
790     auto outlineColorVal4 = nodeAPI->getAttribute(rootNode, NODE_OUTLINE_COLOR);
791     EXPECT_EQ(outlineColorVal4->value[0].u32, color);
792 
793     value2[0].f32 = size;
794     value2[1].f32 = size;
795     nodeAPI->setAttribute(rootNode, NODE_SIZE, &item2);
796     auto sizeVal = nodeAPI->getAttribute(rootNode, NODE_SIZE);
797     EXPECT_EQ(sizeVal->value[0].f32, size);
798 
799     value[0].i32 = false;
800     nodeAPI->setAttribute(rootNode, NODE_RENDER_GROUP, &item);
801     auto renderGroupVal = nodeAPI->getAttribute(rootNode, NODE_RENDER_GROUP);
802     EXPECT_EQ(renderGroupVal->value[0].i32, 0);
803 
804     value[0].u32 = color;
805     nodeAPI->setAttribute(rootNode, NODE_COLOR_BLEND, &item);
806     auto colorBlendVal = nodeAPI->getAttribute(rootNode, NODE_COLOR_BLEND);
807     EXPECT_EQ(colorBlendVal->value[0].u32, color);
808 
809     value4[0].i32 = 0;
810     value4[1].i32 = 0;
811     value4[2].i32 = 100;
812     value4[3].i32 = 100;
813     nodeAPI->setAttribute(rootNode, NODE_LAYOUT_RECT, &item4);
814     auto layoutRectVal = nodeAPI->getAttribute(rootNode, NODE_LAYOUT_RECT);
815     EXPECT_EQ(layoutRectVal->value[0].i32, 0);
816 
817     value[0].i32 = 1;
818     nodeAPI->setAttribute(rootNode, NODE_FOCUS_ON_TOUCH, &item);
819     auto onTouchVal = nodeAPI->getAttribute(rootNode, NODE_FOCUS_ON_TOUCH);
820     EXPECT_EQ(onTouchVal->value[0].i32, 1);
821 
822     value[0].f32 = val01;
823     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item);
824     auto borderWidthPercentVal = nodeAPI->getAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT);
825     EXPECT_EQ(borderWidthPercentVal->value[0].f32, val01);
826     value4[0].f32 = val01;
827     value4[1].f32 = val01;
828     value4[2].f32 = val01;
829     value4[3].f32 = val01;
830     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item4);
831     auto borderWidthPercentVal4 = nodeAPI->getAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT);
832     EXPECT_EQ(borderWidthPercentVal4->value[0].f32, val01);
833 
834     value[0].f32 = val01;
835     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item);
836     auto borderRadiusPercentVal = nodeAPI->getAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT);
837     EXPECT_EQ(borderRadiusPercentVal->value[0].f32, val01);
838     value4[0].f32 = val01;
839     value4[1].f32 = val01;
840     value4[2].f32 = val01;
841     value4[3].f32 = val01;
842     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item4);
843     auto borderRadiusPercentVal4 = nodeAPI->getAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT);
844     EXPECT_EQ(borderRadiusPercentVal4->value[0].f32, val01);
845 
846     auto accessibilityIdVal = nodeAPI->getAttribute(rootNode, NODE_ACCESSIBILITY_ID);
847     EXPECT_NE(accessibilityIdVal, nullptr);
848 
849     value[0].u32 = ARKUI_ACCESSIBILITY_ACTION_CLICK;
850     nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ACTIONS, &item);
851     auto accessibilityActionVal = nodeAPI->getAttribute(rootNode, NODE_ACCESSIBILITY_ACTIONS);
852     EXPECT_NE(accessibilityActionVal, nullptr);
853 
854 
855     value[0].u32 = ARKUI_NODE_STACK;
856     nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ROLE, &item);
857     auto accessibilityRoleVal = nodeAPI->getAttribute(rootNode, NODE_ACCESSIBILITY_ROLE);
858     EXPECT_NE(accessibilityRoleVal, nullptr);
859 
860     value2[0].u32 = ARKUI_SAFE_AREA_TYPE_SYSTEM;
861     value2[1].u32 = ARKUI_SAFE_AREA_EDGE_TOP;
862     nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &item2);
863     auto extendSafeAreaVal = nodeAPI->getAttribute(rootNode, NODE_EXPAND_SAFE_AREA);
864     EXPECT_EQ(extendSafeAreaVal->value[0].u32, ARKUI_SAFE_AREA_TYPE_SYSTEM);
865 
866     value[0].i32 = ARKUI_ALIGNMENT_CENTER;
867     nodeAPI->setAttribute(rootNode, NODE_STACK_ALIGN_CONTENT, &item);
868     auto stackAlignVal = nodeAPI->getAttribute(rootNode, NODE_STACK_ALIGN_CONTENT);
869     EXPECT_EQ(stackAlignVal->value[0].i32, static_cast<int32_t>(ARKUI_ALIGNMENT_CENTER));
870 
871     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TRANSITION), nullptr);
872 
873     value[0].f32 = val05;
874     nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO, &item);
875     value[0].f32 = val01;
876     nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO, &item);
877     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO), nullptr);
878 
879     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
880     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_HEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
881     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
882     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_PADDING), ARKUI_ERROR_CODE_NO_ERROR);
883     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_MARGIN), ARKUI_ERROR_CODE_NO_ERROR);
884     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ID), ARKUI_ERROR_CODE_NO_ERROR);
885     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ENABLED), ARKUI_ERROR_CODE_NO_ERROR);
886     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TRANSLATE), ARKUI_ERROR_CODE_NO_ERROR);
887     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCALE), ARKUI_ERROR_CODE_NO_ERROR);
888     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ROTATE), ARKUI_ERROR_CODE_NO_ERROR);
889     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BRIGHTNESS), ARKUI_ERROR_CODE_NO_ERROR);
890     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SATURATION), ARKUI_ERROR_CODE_NO_ERROR);
891     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BLUR), ARKUI_ERROR_CODE_NO_ERROR);
892     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LINEAR_GRADIENT), ARKUI_ERROR_CODE_NO_ERROR);
893     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ALIGNMENT), ARKUI_ERROR_CODE_NO_ERROR);
894     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_OPACITY), ARKUI_ERROR_CODE_NO_ERROR);
895     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
896     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_RADIUS), ARKUI_ERROR_CODE_NO_ERROR);
897     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
898     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
899     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_Z_INDEX), ARKUI_ERROR_CODE_NO_ERROR);
900     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_VISIBILITY), ARKUI_ERROR_CODE_NO_ERROR);
901     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CLIP), ARKUI_ERROR_CODE_NO_ERROR);
902     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CLIP_SHAPE), ARKUI_ERROR_CODE_NO_ERROR);
903     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TRANSFORM), ARKUI_ERROR_CODE_NO_ERROR);
904     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR), ARKUI_ERROR_CODE_NO_ERROR);
905     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_POSITION), ARKUI_ERROR_CODE_NO_ERROR);
906     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SHADOW), ARKUI_ERROR_CODE_NO_ERROR);
907     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CUSTOM_SHADOW), ARKUI_ERROR_CODE_NO_ERROR);
908     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_IMAGE), ARKUI_ERROR_CODE_NO_ERROR);
909     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
910     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
911     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
912     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TRANSFORM_CENTER), ARKUI_ERROR_CODE_NO_ERROR);
913     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_OPACITY_TRANSITION), ARKUI_ERROR_CODE_NO_ERROR);
914     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ROTATE_TRANSITION), ARKUI_ERROR_CODE_NO_ERROR);
915     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCALE_TRANSITION), ARKUI_ERROR_CODE_NO_ERROR);
916     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TRANSLATE_TRANSITION), ARKUI_ERROR_CODE_NO_ERROR);
917     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_MOVE_TRANSITION), ARKUI_ERROR_CODE_NO_ERROR);
918     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FOCUSABLE), ARKUI_ERROR_CODE_NO_ERROR);
919     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DEFAULT_FOCUS), ARKUI_ERROR_CODE_NO_ERROR);
920     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RESPONSE_REGION), ARKUI_ERROR_CODE_NO_ERROR);
921     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_OVERLAY), ARKUI_ERROR_CODE_NO_ERROR);
922     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWEEP_GRADIENT), ARKUI_ERROR_CODE_NO_ERROR);
923     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIAL_GRADIENT), ARKUI_ERROR_CODE_NO_ERROR);
924     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_MASK), ARKUI_ERROR_CODE_NO_ERROR);
925     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BLEND_MODE), ARKUI_ERROR_CODE_NO_ERROR);
926     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
927     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CONSTRAINT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
928     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRAY_SCALE), ARKUI_ERROR_CODE_NO_ERROR);
929     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_INVERT), ARKUI_ERROR_CODE_NO_ERROR);
930     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SEPIA), ARKUI_ERROR_CODE_NO_ERROR);
931     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CONTRAST), ARKUI_ERROR_CODE_NO_ERROR);
932     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FOREGROUND_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
933     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
934     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_MARK_ANCHOR), ARKUI_ERROR_CODE_NO_ERROR);
935     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_IMAGE_POSITION), ARKUI_ERROR_CODE_NO_ERROR);
936     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_GROUP), ARKUI_ERROR_CODE_NO_ERROR);
937     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_TEXT), ARKUI_ERROR_CODE_NO_ERROR);
938     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_MODE), ARKUI_ERROR_CODE_NO_ERROR);
939     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_DESCRIPTION), ARKUI_ERROR_CODE_NO_ERROR);
940     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FOCUS_STATUS), ARKUI_ERROR_CODE_NO_ERROR);
941     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ASPECT_RATIO), ARKUI_ERROR_CODE_NO_ERROR);
942     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LAYOUT_WEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
943     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DISPLAY_PRIORITY), ARKUI_ERROR_CODE_NO_ERROR);
944     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_OUTLINE_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
945     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WIDTH_PERCENT), ARKUI_ERROR_CODE_NO_ERROR);
946     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_HEIGHT_PERCENT), ARKUI_ERROR_CODE_NO_ERROR);
947     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_PADDING_PERCENT), ARKUI_ERROR_CODE_NO_ERROR);
948     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_MARGIN_PERCENT), ARKUI_ERROR_CODE_NO_ERROR);
949     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GEOMETRY_TRANSITION), ARKUI_ERROR_CODE_NO_ERROR);
950     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RENDER_FIT), ARKUI_ERROR_CODE_NO_ERROR);
951     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_OUTLINE_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
952     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
953     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RENDER_GROUP), ARKUI_ERROR_CODE_NO_ERROR);
954     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_COLOR_BLEND), ARKUI_ERROR_CODE_NO_ERROR);
955     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FOREGROUND_BLUR_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
956     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LAYOUT_RECT), ARKUI_ERROR_CODE_NO_ERROR);
957     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FOCUS_ON_TOUCH), ARKUI_ERROR_CODE_NO_ERROR);
958     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT), ARKUI_ERROR_CODE_NO_ERROR);
959     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT), ARKUI_ERROR_CODE_NO_ERROR);
960     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_ID), ARKUI_ERROR_CODE_NO_ERROR);
961     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_ACTIONS), ARKUI_ERROR_CODE_NO_ERROR);
962     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_ROLE), ARKUI_ERROR_CODE_NO_ERROR);
963     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_STATE), ARKUI_ERROR_CODE_NO_ERROR);
964     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ACCESSIBILITY_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
965     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_EXPAND_SAFE_AREA), ARKUI_ERROR_CODE_NO_ERROR);
966     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO), ARKUI_ERROR_CODE_NO_ERROR);
967     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TRANSITION), ARKUI_ERROR_CODE_NO_ERROR);
968     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_STACK_ALIGN_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
969 }
970 
971 /**
972  * @tc.name: NativeNodeTest006
973  * @tc.desc: Test ConvertOriginEventType function.
974  * @tc.type: FUNC
975  */
976 HWTEST_F(NativeNodeTest, NativeNodeTest006, TestSize.Level1)
977 {
978     int32_t ret;
979     int32_t nodeType = static_cast<int32_t>(ARKUI_NODE_TEXT_INPUT);
980     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_CHANGE, nodeType);
981     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_CHANGE));
982     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_SUBMIT, nodeType);
983     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_SUBMIT));
984     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_CUT, nodeType);
985     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_CUT));
986     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_PASTE, nodeType);
987     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_PASTE));
988     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_TEXT_SELECTION_CHANGE, nodeType);
989     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_TEXT_SELECTION_CHANGE));
990     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_EDIT_CHANGE, nodeType);
991     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_EDIT_CHANGE));
992     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_CONTENT_SIZE_CHANGE, nodeType);
993     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_CONTENT_SIZE_CHANGE));
994     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_INPUT_FILTER_ERROR, nodeType);
995     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_INPUT_FILTER_ERROR));
996     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_CONTENT_SCROLL, nodeType);
997     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_CONTENT_SCROLL));
998     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_WILL_INSERT, nodeType);
999     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_WILL_INSERT));
1000     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_DID_INSERT, nodeType);
1001     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_DID_INSERT));
1002     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_WILL_DELETE, nodeType);
1003     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_WILL_DELETE));
1004     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_DID_DELETE, nodeType);
1005     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_DID_DELETE));
1006     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_INPUT_ON_CHANGE_WITH_PREVIEW_TEXT, nodeType);
1007     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_INPUT_CHANGE_WITH_PREVIEW_TEXT));
1008 
1009     nodeType = static_cast<int32_t>(ARKUI_NODE_SCROLL);
1010     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL, nodeType);
1011     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL));
1012     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN, nodeType);
1013     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL_FRAME_BEGIN));
1014     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_WILL_SCROLL, nodeType);
1015     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL_WILL_SCROLL));
1016     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_DID_SCROLL, nodeType);
1017     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL_DID_SCROLL));
1018     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_START, nodeType);
1019     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL_START));
1020     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_STOP, nodeType);
1021     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL_STOP));
1022     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_EDGE, nodeType);
1023     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL_EDGE));
1024     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_REACH_START, nodeType);
1025     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL_REACH_START));
1026     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_REACH_END, nodeType);
1027     EXPECT_EQ(ret, static_cast<int32_t>(ON_SCROLL_REACH_END));
1028 
1029     nodeType = static_cast<int32_t>(ARKUI_NODE_LIST);
1030     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL, nodeType);
1031     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_SCROLL));
1032     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN, nodeType);
1033     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_SCROLL_FRAME_BEGIN));
1034     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_START, nodeType);
1035     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_SCROLL_START));
1036     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_STOP, nodeType);
1037     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_SCROLL_STOP));
1038     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_REACH_START, nodeType);
1039     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_REACH_START));
1040     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_REACH_END, nodeType);
1041     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_REACH_END));
1042     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_LIST_ON_SCROLL_INDEX, nodeType);
1043     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_SCROLL_INDEX));
1044     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_LIST_ON_DID_SCROLL, nodeType);
1045     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_DID_SCROLL));
1046     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_LIST_ON_WILL_SCROLL, nodeType);
1047     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_WILL_SCROLL));
1048 
1049     nodeType = static_cast<int32_t>(ARKUI_NODE_WATER_FLOW);
1050     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN, nodeType);
1051     EXPECT_EQ(ret, static_cast<int32_t>(ON_WATER_FLOW_SCROLL_FRAME_BEGIN));
1052     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_START, nodeType);
1053     EXPECT_EQ(ret, static_cast<int32_t>(ON_WATER_FLOW_SCROLL_START));
1054     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_STOP, nodeType);
1055     EXPECT_EQ(ret, static_cast<int32_t>(ON_WATER_FLOW_SCROLL_STOP));
1056     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_WILL_SCROLL, nodeType);
1057     EXPECT_EQ(ret, static_cast<int32_t>(ON_WATER_FLOW_WILL_SCROLL));
1058     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_REACH_START, nodeType);
1059     EXPECT_EQ(ret, static_cast<int32_t>(ON_WATER_FLOW_REACH_START));
1060     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_REACH_END, nodeType);
1061     EXPECT_EQ(ret, static_cast<int32_t>(ON_WATER_FLOW_REACH_END));
1062     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_WATER_FLOW_ON_DID_SCROLL, nodeType);
1063     EXPECT_EQ(ret, static_cast<int32_t>(ON_WATER_FLOW_DID_SCROLL));
1064     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_WATER_FLOW_ON_SCROLL_INDEX, nodeType);
1065     EXPECT_EQ(ret, static_cast<int32_t>(ON_WATER_FLOW_SCROLL_INDEX));
1066 
1067     nodeType = static_cast<int32_t>(ARKUI_NODE_STACK);
1068     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_EVENT_ON_APPEAR, nodeType);
1069     EXPECT_EQ(ret, static_cast<int32_t>(ON_APPEAR));
1070     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_EVENT_ON_DISAPPEAR, nodeType);
1071     EXPECT_EQ(ret, static_cast<int32_t>(ON_DISAPPEAR));
1072     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_EVENT_ON_AREA_CHANGE, nodeType);
1073     EXPECT_EQ(ret, static_cast<int32_t>(ON_AREA_CHANGE));
1074     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_FOCUS, nodeType);
1075     EXPECT_EQ(ret, static_cast<int32_t>(ON_FOCUS));
1076     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_BLUR, nodeType);
1077     EXPECT_EQ(ret, static_cast<int32_t>(ON_BLUR));
1078     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TOUCH_EVENT, nodeType);
1079     EXPECT_EQ(ret, static_cast<int32_t>(ON_TOUCH));
1080     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_CLICK, nodeType);
1081     EXPECT_EQ(ret, static_cast<int32_t>(ON_CLICK));
1082     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_TOUCH_INTERCEPT, nodeType);
1083     EXPECT_EQ(ret, static_cast<int32_t>(ON_TOUCH_INTERCEPT));
1084     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_EVENT_ON_VISIBLE_AREA_CHANGE, nodeType);
1085     EXPECT_EQ(ret, static_cast<int32_t>(ON_VISIBLE_AREA_CHANGE));
1086     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_HOVER, nodeType);
1087     EXPECT_EQ(ret, static_cast<int32_t>(ON_HOVER));
1088     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_HOVER_MOVE, nodeType);
1089     EXPECT_EQ(ret, static_cast<int32_t>(ON_HOVER_MOVE));
1090     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_MOUSE, nodeType);
1091     EXPECT_EQ(ret, static_cast<int32_t>(ON_MOUSE));
1092     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_EVENT_ON_ATTACH, nodeType);
1093     EXPECT_EQ(ret, static_cast<int32_t>(ON_ATTACH));
1094     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_EVENT_ON_DETACH, nodeType);
1095     EXPECT_EQ(ret, static_cast<int32_t>(ON_DETACH));
1096     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_ACCESSIBILITY_ACTIONS, nodeType);
1097     EXPECT_EQ(ret, static_cast<int32_t>(ON_ACCESSIBILITY_ACTIONS));
1098 
1099     nodeType = static_cast<int32_t>(ARKUI_NODE_TEXT_AREA);
1100     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_CHANGE, nodeType);
1101     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXTAREA_CHANGE));
1102     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_INPUT_FILTER_ERROR, nodeType);
1103     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_AREA_INPUT_FILTER_ERROR));
1104     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_EDIT_CHANGE, nodeType);
1105     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXTAREA_EDIT_CHANGE));
1106     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_SUBMIT, nodeType);
1107     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXTAREA_ON_SUBMIT));
1108     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_CONTENT_SIZE_CHANGE, nodeType);
1109     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXTAREA_CONTENT_SIZE_CHANGE));
1110     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_PASTE, nodeType);
1111     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXTAREA_PASTE));
1112     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_TEXT_SELECTION_CHANGE, nodeType);
1113     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXTAREA_TEXT_SELECTION_CHANGE));
1114     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_CONTENT_SCROLL, nodeType);
1115     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_AREA_CONTENT_SCROLL));
1116     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_WILL_INSERT, nodeType);
1117     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_AREA_WILL_INSERT));
1118     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_DID_INSERT, nodeType);
1119     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_AREA_DID_INSERT));
1120     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_WILL_DELETE, nodeType);
1121     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_AREA_WILL_DELETE));
1122     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_DID_DELETE, nodeType);
1123     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_AREA_DID_DELETE));
1124     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_AREA_ON_CHANGE_WITH_PREVIEW_TEXT, nodeType);
1125     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_AREA_CHANGE_WITH_PREVIEW_TEXT));
1126 
1127 
1128     nodeType = static_cast<int32_t>(ARKUI_NODE_REFRESH);
1129     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_REFRESH_STATE_CHANGE, nodeType);
1130     EXPECT_EQ(ret, static_cast<int32_t>(ON_REFRESH_STATE_CHANGE));
1131     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_REFRESH_ON_REFRESH, nodeType);
1132     EXPECT_EQ(ret, static_cast<int32_t>(ON_REFRESH_REFRESHING));
1133     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_REFRESH_ON_OFFSET_CHANGE, nodeType);
1134     EXPECT_EQ(ret, static_cast<int32_t>(ON_REFRESH_ON_OFFSET_CHANGE));
1135     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_KEY_EVENT, nodeType);
1136     EXPECT_EQ(ret, static_cast<int32_t>(ArkUIEventSubKind::ON_KEY_EVENT));
1137     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_KEY_PRE_IME, nodeType);
1138     EXPECT_EQ(ret, static_cast<int32_t>(ArkUIEventSubKind::ON_KEY_PREIME));
1139     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_CLICK_EVENT, nodeType);
1140     EXPECT_EQ(ret, static_cast<int32_t>(ArkUIEventSubKind::ON_CLICK_EVENT));
1141     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_HOVER_EVENT, nodeType);
1142     EXPECT_EQ(ret, static_cast<int32_t>(ArkUIEventSubKind::ON_HOVER_EVENT));
1143 
1144     nodeType = static_cast<int32_t>(ARKUI_NODE_TOGGLE);
1145     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TOGGLE_ON_CHANGE, nodeType);
1146     EXPECT_EQ(ret, static_cast<int32_t>(ON_TOGGLE_CHANGE));
1147 
1148     nodeType = static_cast<int32_t>(ARKUI_NODE_IMAGE);
1149     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ON_COMPLETE, nodeType);
1150     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_COMPLETE));
1151     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ON_ERROR, nodeType);
1152     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_ERROR));
1153     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ON_SVG_PLAY_FINISH, nodeType);
1154     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_SVG_PLAY_FINISH));
1155     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ON_DOWNLOAD_PROGRESS, nodeType);
1156     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_DOWNLOAD_PROGRESS));
1157 
1158     nodeType = static_cast<int32_t>(ARKUI_NODE_DATE_PICKER);
1159     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_DATE_PICKER_EVENT_ON_DATE_CHANGE, nodeType);
1160     EXPECT_EQ(ret, static_cast<int32_t>(ON_DATE_PICKER_DATE_CHANGE));
1161 
1162     nodeType = static_cast<int32_t>(ARKUI_NODE_TIME_PICKER);
1163     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TIME_PICKER_EVENT_ON_CHANGE, nodeType);
1164     EXPECT_EQ(ret, static_cast<int32_t>(ON_TIME_PICKER_CHANGE));
1165 
1166     nodeType = static_cast<int32_t>(ARKUI_NODE_TEXT_PICKER);
1167     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_PICKER_EVENT_ON_CHANGE, nodeType);
1168     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_PICKER_CHANGE));
1169     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_PICKER_EVENT_ON_SCROLL_STOP, nodeType);
1170     EXPECT_EQ(ret, static_cast<int32_t>(ON_TEXT_PICKER_SCROLL_STOP));
1171 
1172     nodeType = static_cast<int32_t>(ARKUI_NODE_CALENDAR_PICKER);
1173     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_CALENDAR_PICKER_EVENT_ON_CHANGE, nodeType);
1174     EXPECT_EQ(ret, static_cast<int32_t>(ON_CALENDAR_PICKER_CHANGE));
1175 
1176     nodeType = static_cast<int32_t>(ARKUI_NODE_CHECKBOX);
1177     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_CHECKBOX_EVENT_ON_CHANGE, nodeType);
1178     EXPECT_EQ(ret, static_cast<int32_t>(ON_CHECKBOX_CHANGE));
1179 
1180     nodeType = static_cast<int32_t>(ARKUI_NODE_SLIDER);
1181     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SLIDER_EVENT_ON_CHANGE, nodeType);
1182     EXPECT_EQ(ret, static_cast<int32_t>(ON_SLIDER_CHANGE));
1183 
1184     nodeType = static_cast<int32_t>(ARKUI_NODE_SWIPER);
1185     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SWIPER_EVENT_ON_CHANGE, nodeType);
1186     EXPECT_EQ(ret, static_cast<int32_t>(ON_SWIPER_CHANGE));
1187     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SWIPER_EVENT_ON_SELECTED, nodeType);
1188     EXPECT_EQ(ret, static_cast<int32_t>(ON_SWIPER_SELECTED));
1189     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SWIPER_EVENT_ON_ANIMATION_START, nodeType);
1190     EXPECT_EQ(ret, static_cast<int32_t>(ON_SWIPER_ANIMATION_START));
1191     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SWIPER_EVENT_ON_ANIMATION_END, nodeType);
1192     EXPECT_EQ(ret, static_cast<int32_t>(ON_SWIPER_ANIMATION_END));
1193     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SWIPER_EVENT_ON_GESTURE_SWIPE, nodeType);
1194     EXPECT_EQ(ret, static_cast<int32_t>(ON_SWIPER_GESTURE_SWIPE));
1195     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SWIPER_EVENT_ON_CONTENT_DID_SCROLL, nodeType);
1196     EXPECT_EQ(ret, static_cast<int32_t>(ON_SWIPER_DID_CONTENT_SCROLL));
1197     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SWIPER_EVENT_ON_UNSELECTED, nodeType);
1198     EXPECT_EQ(ret, static_cast<int32_t>(ON_SWIPER_UNSELECTED));
1199 
1200     nodeType = static_cast<int32_t>(ARKUI_NODE_TEXT);
1201     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_TEXT_ON_DETECT_RESULT_UPDATE, nodeType);
1202     EXPECT_EQ(ret, static_cast<int32_t>(ON_DETECT_RESULT_UPDATE));
1203 
1204     nodeType = static_cast<int32_t>(ARKUI_NODE_RADIO);
1205     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_RADIO_EVENT_ON_CHANGE, nodeType);
1206     EXPECT_EQ(ret, static_cast<int32_t>(ON_RADIO_CHANGE));
1207 
1208     nodeType = static_cast<int32_t>(ARKUI_NODE_IMAGE_ANIMATOR);
1209     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ANIMATOR_EVENT_ON_START, nodeType);
1210     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_ANIMATOR_ON_START));
1211     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ANIMATOR_EVENT_ON_CANCEL, nodeType);
1212     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_ANIMATOR_ON_CANCEL));
1213     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ANIMATOR_EVENT_ON_PAUSE, nodeType);
1214     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_ANIMATOR_ON_PAUSE));
1215     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ANIMATOR_EVENT_ON_REPEAT, nodeType);
1216     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_ANIMATOR_ON_REPEAT));
1217     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_IMAGE_ANIMATOR_EVENT_ON_FINISH, nodeType);
1218     EXPECT_EQ(ret, static_cast<int32_t>(ON_IMAGE_ANIMATOR_ON_FINISH));
1219 
1220     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_FOCUS_AXIS, nodeType);
1221     EXPECT_EQ(ret, static_cast<int32_t>(ON_FOCUS_AXIS));
1222     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_CHECKBOX_GROUP_EVENT_ON_CHANGE, nodeType);
1223     EXPECT_EQ(ret, static_cast<int32_t>(ON_CHECKBOX_GROUP_CHANGE));
1224     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_AXIS, nodeType);
1225     EXPECT_EQ(ret, static_cast<int32_t>(ON_AXIS));
1226 }
1227 
1228 /**
1229  * @tc.name: NativeNodeTest007
1230  * @tc.desc: Test ConvertToNodeEventType function.
1231  * @tc.type: FUNC
1232  */
1233 HWTEST_F(NativeNodeTest, NativeNodeTest007, TestSize.Level1)
1234 {
1235     int32_t ret;
1236     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_CHANGE);
1237     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_CHANGE));
1238     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_SUBMIT);
1239     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_SUBMIT));
1240     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_CUT);
1241     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_CUT));
1242     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_PASTE);
1243     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_PASTE));
1244     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_TEXT_SELECTION_CHANGE);
1245     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_TEXT_SELECTION_CHANGE));
1246     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_EDIT_CHANGE);
1247     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_EDIT_CHANGE));
1248     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_CONTENT_SIZE_CHANGE);
1249     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_CONTENT_SIZE_CHANGE));
1250     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_INPUT_FILTER_ERROR);
1251     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_INPUT_FILTER_ERROR));
1252     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_CONTENT_SCROLL);
1253     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_CONTENT_SCROLL));
1254     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_WILL_INSERT);
1255     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_WILL_INSERT));
1256     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_DID_INSERT);
1257     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_DID_INSERT));
1258     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_WILL_DELETE);
1259     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_WILL_DELETE));
1260     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_DID_DELETE);
1261     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_DID_DELETE));
1262     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_INPUT_CHANGE_WITH_PREVIEW_TEXT);
1263     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_INPUT_ON_CHANGE_WITH_PREVIEW_TEXT));
1264     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL);
1265     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL));
1266     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL_FRAME_BEGIN);
1267     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN));
1268     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL_WILL_SCROLL);
1269     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_WILL_SCROLL));
1270     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL_DID_SCROLL);
1271     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_DID_SCROLL));
1272     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL_START);
1273     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_START));
1274     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL_STOP);
1275     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_STOP));
1276     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL_EDGE);
1277     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_EDGE));
1278     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL_REACH_START);
1279     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_REACH_START));
1280     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SCROLL_REACH_END);
1281     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_REACH_END));
1282     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_SCROLL);
1283     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL));
1284     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_SCROLL_FRAME_BEGIN);
1285     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN));
1286     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_SCROLL_START);
1287     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_START));
1288     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_SCROLL_STOP);
1289     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_STOP));
1290     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_REACH_START);
1291     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_REACH_START));
1292     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_REACH_END);
1293     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_REACH_END));
1294     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_SCROLL_INDEX);
1295     EXPECT_EQ(ret, static_cast<int32_t>(NODE_LIST_ON_SCROLL_INDEX));
1296     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_DID_SCROLL);
1297     EXPECT_EQ(ret, static_cast<int32_t>(NODE_LIST_ON_DID_SCROLL));
1298     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_WILL_SCROLL);
1299     EXPECT_EQ(ret, static_cast<int32_t>(NODE_LIST_ON_WILL_SCROLL));
1300     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_WATER_FLOW_SCROLL_FRAME_BEGIN);
1301     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN));
1302     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_WATER_FLOW_SCROLL_START);
1303     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_START));
1304     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_WATER_FLOW_SCROLL_STOP);
1305     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_SCROLL_STOP));
1306     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_WATER_FLOW_WILL_SCROLL);
1307     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_WILL_SCROLL));
1308     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_WATER_FLOW_REACH_START);
1309     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_REACH_START));
1310     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_WATER_FLOW_REACH_END);
1311     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SCROLL_EVENT_ON_REACH_END));
1312     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_WATER_FLOW_DID_SCROLL);
1313     EXPECT_EQ(ret, static_cast<int32_t>(NODE_WATER_FLOW_ON_DID_SCROLL));
1314     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_WATER_FLOW_SCROLL_INDEX);
1315     EXPECT_EQ(ret, static_cast<int32_t>(NODE_WATER_FLOW_ON_SCROLL_INDEX));
1316     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_APPEAR);
1317     EXPECT_EQ(ret, static_cast<int32_t>(NODE_EVENT_ON_APPEAR));
1318     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DISAPPEAR);
1319     EXPECT_EQ(ret, static_cast<int32_t>(NODE_EVENT_ON_DISAPPEAR));
1320     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_AREA_CHANGE);
1321     EXPECT_EQ(ret, static_cast<int32_t>(NODE_EVENT_ON_AREA_CHANGE));
1322     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_FOCUS);
1323     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_FOCUS));
1324     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_BLUR);
1325     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_BLUR));
1326     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TOUCH);
1327     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TOUCH_EVENT));
1328     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_CLICK);
1329     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_CLICK));
1330     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TOUCH_INTERCEPT);
1331     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_TOUCH_INTERCEPT));
1332     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_VISIBLE_AREA_CHANGE);
1333     EXPECT_EQ(ret, static_cast<int32_t>(NODE_EVENT_ON_VISIBLE_AREA_CHANGE));
1334     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_HOVER);
1335     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_HOVER));
1336     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_HOVER_MOVE);
1337     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_HOVER_MOVE));
1338     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_MOUSE);
1339     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_MOUSE));
1340     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_ATTACH);
1341     EXPECT_EQ(ret, static_cast<int32_t>(NODE_EVENT_ON_ATTACH));
1342     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DETACH);
1343     EXPECT_EQ(ret, static_cast<int32_t>(NODE_EVENT_ON_DETACH));
1344     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_ACCESSIBILITY_ACTIONS);
1345     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_ACCESSIBILITY_ACTIONS));
1346     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXTAREA_CHANGE);
1347     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_CHANGE));
1348     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_AREA_INPUT_FILTER_ERROR);
1349     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_INPUT_FILTER_ERROR));
1350     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXTAREA_EDIT_CHANGE);
1351     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_EDIT_CHANGE));
1352     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXTAREA_ON_SUBMIT);
1353     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_SUBMIT));
1354     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXTAREA_CONTENT_SIZE_CHANGE);
1355     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_CONTENT_SIZE_CHANGE));
1356     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXTAREA_PASTE);
1357     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_PASTE));
1358     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXTAREA_TEXT_SELECTION_CHANGE);
1359     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_TEXT_SELECTION_CHANGE));
1360     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_AREA_CONTENT_SCROLL);
1361     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_CONTENT_SCROLL));
1362     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_AREA_WILL_INSERT);
1363     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_WILL_INSERT));
1364     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_AREA_DID_INSERT);
1365     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_DID_INSERT));
1366     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_AREA_WILL_DELETE);
1367     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_WILL_DELETE));
1368     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_AREA_DID_DELETE);
1369     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_DID_DELETE));
1370     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_AREA_CHANGE_WITH_PREVIEW_TEXT);
1371     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_AREA_ON_CHANGE_WITH_PREVIEW_TEXT));
1372     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_REFRESH_STATE_CHANGE);
1373     EXPECT_EQ(ret, static_cast<int32_t>(NODE_REFRESH_STATE_CHANGE));
1374     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_REFRESH_REFRESHING);
1375     EXPECT_EQ(ret, static_cast<int32_t>(NODE_REFRESH_ON_REFRESH));
1376     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_REFRESH_ON_OFFSET_CHANGE);
1377     EXPECT_EQ(ret, static_cast<int32_t>(NODE_REFRESH_ON_OFFSET_CHANGE));
1378     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TOGGLE_CHANGE);
1379     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TOGGLE_ON_CHANGE));
1380     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_COMPLETE);
1381     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ON_COMPLETE));
1382     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_ERROR);
1383     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ON_ERROR));
1384     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_SVG_PLAY_FINISH);
1385     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ON_SVG_PLAY_FINISH));
1386     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_DOWNLOAD_PROGRESS);
1387     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ON_DOWNLOAD_PROGRESS));
1388     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DATE_PICKER_DATE_CHANGE);
1389     EXPECT_EQ(ret, static_cast<int32_t>(NODE_DATE_PICKER_EVENT_ON_DATE_CHANGE));
1390     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TIME_PICKER_CHANGE);
1391     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TIME_PICKER_EVENT_ON_CHANGE));
1392     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_PICKER_CHANGE);
1393     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_PICKER_EVENT_ON_CHANGE));
1394     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_TEXT_PICKER_SCROLL_STOP);
1395     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_PICKER_EVENT_ON_SCROLL_STOP));
1396     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_CALENDAR_PICKER_CHANGE);
1397     EXPECT_EQ(ret, static_cast<int32_t>(NODE_CALENDAR_PICKER_EVENT_ON_CHANGE));
1398     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_CHECKBOX_CHANGE);
1399     EXPECT_EQ(ret, static_cast<int32_t>(NODE_CHECKBOX_EVENT_ON_CHANGE));
1400     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SLIDER_CHANGE);
1401     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SLIDER_EVENT_ON_CHANGE));
1402     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SWIPER_CHANGE);
1403     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SWIPER_EVENT_ON_CHANGE));
1404     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SWIPER_ANIMATION_START);
1405     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SWIPER_EVENT_ON_ANIMATION_START));
1406     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SWIPER_ANIMATION_END);
1407     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SWIPER_EVENT_ON_ANIMATION_END));
1408     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SWIPER_GESTURE_SWIPE);
1409     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SWIPER_EVENT_ON_GESTURE_SWIPE));
1410     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_SWIPER_DID_CONTENT_SCROLL);
1411     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SWIPER_EVENT_ON_CONTENT_DID_SCROLL));
1412     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DETECT_RESULT_UPDATE);
1413     EXPECT_EQ(ret, static_cast<int32_t>(NODE_TEXT_ON_DETECT_RESULT_UPDATE));
1414     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_RADIO_CHANGE);
1415     EXPECT_EQ(ret, static_cast<int32_t>(NODE_RADIO_EVENT_ON_CHANGE));
1416     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_ANIMATOR_ON_START);
1417     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ANIMATOR_EVENT_ON_START));
1418     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_ANIMATOR_ON_CANCEL);
1419     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ANIMATOR_EVENT_ON_CANCEL));
1420     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_ANIMATOR_ON_PAUSE);
1421     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ANIMATOR_EVENT_ON_PAUSE));
1422     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_ANIMATOR_ON_REPEAT);
1423     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ANIMATOR_EVENT_ON_REPEAT));
1424     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_ANIMATOR_ON_FINISH);
1425     EXPECT_EQ(ret, static_cast<int32_t>(NODE_IMAGE_ANIMATOR_EVENT_ON_FINISH));
1426     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_KEY_EVENT);
1427     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_KEY_EVENT));
1428     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_KEY_PREIME);
1429     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_KEY_PRE_IME));
1430     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_KEY_DISPATCH);
1431     EXPECT_EQ(ret, static_cast<int32_t>(NODE_DISPATCH_KEY_EVENT));
1432     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_CLICK_EVENT);
1433     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_CLICK_EVENT));
1434     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_HOVER_EVENT);
1435     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_HOVER_EVENT));
1436     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_SWIPER_SELECTED);
1437     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SWIPER_EVENT_ON_SELECTED));
1438     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_SWIPER_UNSELECTED);
1439     EXPECT_EQ(ret, static_cast<int32_t>(NODE_SWIPER_EVENT_ON_UNSELECTED));
1440     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_FOCUS_AXIS);
1441     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_FOCUS_AXIS));
1442     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_CHECKBOX_GROUP_CHANGE);
1443     EXPECT_EQ(ret, static_cast<int32_t>(NODE_CHECKBOX_GROUP_EVENT_ON_CHANGE));
1444     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_AXIS);
1445     EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_AXIS));
1446 }
1447 
1448 /**
1449  * @tc.name: NativeNodeTest008
1450  * @tc.desc: Test textNode function.
1451  * @tc.type: FUNC
1452  */
1453 HWTEST_F(NativeNodeTest, NativeNodeTest008, TestSize.Level1)
1454 {
1455     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1456         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1457     auto rootNode = new ArkUI_Node({ARKUI_NODE_TEXT, nullptr, true});
1458     uint32_t color = 0XFFFF0000;
1459     float size = 10.0f;
1460     ArkUI_NumberValue value[] = {{.u32 = color}};
1461     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
1462     ArkUI_NumberValue shadow[] = {{.f32 = size}, {.i32 = ARKUI_SHADOW_TYPE_COLOR}, {.u32 = color}, {.f32 = size},
1463         {.f32 = size}};
1464     ArkUI_AttributeItem shadowItem = {shadow, sizeof(shadow) / sizeof(ArkUI_NumberValue)};
1465     ArkUI_NumberValue fontValue[] = {{.f32 = size}, {.i32 = ARKUI_FONT_WEIGHT_NORMAL},
1466         {.i32 = ARKUI_FONT_STYLE_NORMAL}};
1467     ArkUI_AttributeItem fontItem = {fontValue, sizeof(fontValue) / sizeof(ArkUI_NumberValue)};
1468     ArkUI_NumberValue decoration[] = {{.i32 = ARKUI_TEXT_DECORATION_TYPE_UNDERLINE}, {.u32 = color},
1469         {.i32 = ARKUI_TEXT_DECORATION_STYLE_SOLID}};
1470     ArkUI_AttributeItem decorationItem = {decoration, sizeof(decoration) / sizeof(ArkUI_NumberValue)};
1471     nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item);
1472     nodeAPI->setAttribute(rootNode, NODE_TEXT_SELECTED_BACKGROUND_COLOR, &item);
1473     value[0].f32 = size;
1474     nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item);
1475     nodeAPI->setAttribute(rootNode, NODE_TEXT_BASELINE_OFFSET, &item);
1476     nodeAPI->setAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE, &item);
1477     nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE, &item);
1478     nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &item);
1479     nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_HEIGHT, &item);
1480     nodeAPI->setAttribute(rootNode, NODE_TEXT_LETTER_SPACING, &item);
1481     nodeAPI->setAttribute(rootNode, NODE_TEXT_INDENT, &item);
1482     nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_SPACING, &item);
1483 
1484     value[0].i32 = ARKUI_FONT_WEIGHT_W100;
1485     nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &item);
1486     value[0].i32 = ARKUI_FONT_STYLE_NORMAL;
1487     nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &item);
1488     value[0].i32 = ARKUI_TEXT_HEIGHT_ADAPTIVE_POLICY_MAX_LINES_FIRST;
1489     nodeAPI->setAttribute(rootNode, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY, &item);
1490     value[0].i32 = ARKUI_COPY_OPTIONS_NONE;
1491     nodeAPI->setAttribute(rootNode, NODE_TEXT_COPY_OPTION, &item);
1492     value[0].i32 = ARKUI_TEXT_DECORATION_TYPE_NONE;
1493     nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &item);
1494     value[0].i32 = ARKUI_TEXT_CASE_NORMAL;
1495     nodeAPI->setAttribute(rootNode, NODE_TEXT_CASE, &item);
1496     value[0].i32 = 1;
1497     nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_LINES, &item);
1498     value[0].i32 = ARKUI_TEXT_ALIGNMENT_START;
1499     nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &item);
1500     value[0].i32 = ARKUI_TEXT_OVERFLOW_NONE;
1501     nodeAPI->setAttribute(rootNode, NODE_TEXT_OVERFLOW, &item);
1502     value[0].i32 = ARKUI_WORD_BREAK_NORMAL;
1503     nodeAPI->setAttribute(rootNode, NODE_TEXT_WORD_BREAK, &item);
1504     value[0].i32 = ARKUI_ELLIPSIS_MODE_START;
1505     nodeAPI->setAttribute(rootNode, NODE_TEXT_ELLIPSIS_MODE, &item);
1506     value[0].i32 = ARKUI_TEXT_DATA_DETECTOR_TYPE_URL;
1507     nodeAPI->setAttribute(rootNode, NODE_TEXT_ENABLE_DATA_DETECTOR_CONFIG, &item);
1508 
1509     value[0].i32 = false;
1510     nodeAPI->setAttribute(rootNode, NODE_TEXT_ENABLE_DATA_DETECTOR, &item);
1511 
1512     item.string = "test";
1513     nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT_FEATURE, &item);
1514 
1515     nodeAPI->setAttribute(rootNode, NODE_TEXT_TEXT_SHADOW, &shadowItem);
1516     nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &fontItem);
1517     fontItem.string = "test";
1518     nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &fontItem);
1519     nodeAPI->setAttribute(rootNode, NODE_FONT_FAMILY, &fontItem);
1520     nodeAPI->setAttribute(rootNode, NODE_TEXT_CONTENT, &fontItem);
1521     nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &decorationItem);
1522     value[0].i32 = true;
1523     nodeAPI->setAttribute(rootNode, NODE_TEXT_HALF_LEADING, &item);
1524     decoration[2].i32 = -1;
1525     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &decorationItem), ARKUI_ERROR_CODE_PARAM_INVALID);
1526 
1527     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
1528     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1529     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
1530     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
1531     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_WEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
1532     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_LINE_HEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
1533     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_DECORATION), ARKUI_ERROR_CODE_NO_ERROR);
1534     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_CASE), ARKUI_ERROR_CODE_NO_ERROR);
1535     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_LETTER_SPACING), ARKUI_ERROR_CODE_NO_ERROR);
1536     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MAX_LINES), ARKUI_ERROR_CODE_NO_ERROR);
1537     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_ALIGN), ARKUI_ERROR_CODE_NO_ERROR);
1538     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_OVERFLOW), ARKUI_ERROR_CODE_NO_ERROR);
1539     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_FAMILY), ARKUI_ERROR_CODE_NO_ERROR);
1540     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_COPY_OPTION), ARKUI_ERROR_CODE_NO_ERROR);
1541     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_BASELINE_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
1542     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_TEXT_SHADOW), ARKUI_ERROR_CODE_NO_ERROR);
1543     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
1544     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
1545     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_FONT), ARKUI_ERROR_CODE_NO_ERROR);
1546     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY), ARKUI_ERROR_CODE_NO_ERROR);
1547     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INDENT), ARKUI_ERROR_CODE_NO_ERROR);
1548     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_WORD_BREAK), ARKUI_ERROR_CODE_NO_ERROR);
1549     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_ELLIPSIS_MODE), ARKUI_ERROR_CODE_NO_ERROR);
1550     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_LINE_SPACING), ARKUI_ERROR_CODE_NO_ERROR);
1551     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_FONT_FEATURE), ARKUI_ERROR_CODE_NO_ERROR);
1552     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_ENABLE_DATA_DETECTOR), ARKUI_ERROR_CODE_NO_ERROR);
1553     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_ENABLE_DATA_DETECTOR_CONFIG), ARKUI_ERROR_CODE_NO_ERROR);
1554     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_SELECTED_BACKGROUND_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1555     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_CONTENT_WITH_STYLED_STRING), ARKUI_ERROR_CODE_NO_ERROR);
1556     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_HALF_LEADING), ARKUI_ERROR_CODE_NO_ERROR);
1557     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_CONTENT), nullptr);
1558     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_COLOR), nullptr);
1559     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_SIZE), nullptr);
1560     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_STYLE), nullptr);
1561     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_WEIGHT), nullptr);
1562     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_LINE_HEIGHT), nullptr);
1563     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_DECORATION), nullptr);
1564     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_CASE), nullptr);
1565     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_LETTER_SPACING), nullptr);
1566     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MAX_LINES), nullptr);
1567     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_ALIGN), nullptr);
1568     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_OVERFLOW), nullptr);
1569     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_FAMILY), nullptr);
1570     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_COPY_OPTION), nullptr);
1571     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_BASELINE_OFFSET), nullptr);
1572     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_TEXT_SHADOW), nullptr);
1573     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE), nullptr);
1574     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE), nullptr);
1575     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_FONT), nullptr);
1576     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY), nullptr);
1577     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INDENT), nullptr);
1578     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_WORD_BREAK), nullptr);
1579     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_ELLIPSIS_MODE), nullptr);
1580     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_LINE_SPACING), nullptr);
1581     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_FONT_FEATURE), nullptr);
1582     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_ENABLE_DATA_DETECTOR), nullptr);
1583     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_ENABLE_DATA_DETECTOR_CONFIG), nullptr);
1584     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_SELECTED_BACKGROUND_COLOR), nullptr);
1585     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_TEXT_CONTENT_WITH_STYLED_STRING), nullptr);
1586     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_HALF_LEADING), nullptr);
1587 
1588     value[0].i32 = ARKUI_FONT_WEIGHT_W100;
1589     nodeAPI->setAttribute(rootNode, NODE_IMMUTABLE_FONT_WEIGHT, &item);
1590     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMMUTABLE_FONT_WEIGHT), nullptr);
1591     nodeAPI->resetAttribute(rootNode, NODE_IMMUTABLE_FONT_WEIGHT);
1592     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMMUTABLE_FONT_WEIGHT), nullptr);
1593     nodeAPI->disposeNode(rootNode);
1594 }
1595 
1596 /**
1597  * @tc.name: NativeNodeTest009
1598  * @tc.desc: Test spanNode function.
1599  * @tc.type: FUNC
1600  */
1601 HWTEST_F(NativeNodeTest, NativeNodeTest009, TestSize.Level1)
1602 {
1603     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1604         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1605     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SPAN);
1606     ASSERT_NE(rootNode, nullptr);
1607     uint32_t color = 0XFFFF0000;
1608     float size = 10.0f;
1609     ArkUI_NumberValue value[] = {{.u32 = color}};
1610     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
1611     ArkUI_NumberValue shadow[] = {{.f32 = size}, {.i32 = ARKUI_SHADOW_TYPE_COLOR}, {.u32 = color}, {.f32 = size},
1612         {.f32 = size}};
1613     ArkUI_AttributeItem shadowItem = {shadow, sizeof(shadow) / sizeof(ArkUI_NumberValue)};
1614     ArkUI_NumberValue backgroundStyle[] = {{.u32 = color}, {.f32 = size}, {.f32 = size}, {.f32 = size},
1615         {.f32 = size}};
1616     ArkUI_AttributeItem backgroundStyleItem = {backgroundStyle, sizeof(backgroundStyle) / sizeof(ArkUI_NumberValue)};
1617     nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item);
1618     value[0].f32 = size;
1619     nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item);
1620     nodeAPI->setAttribute(rootNode, NODE_SPAN_BASELINE_OFFSET, &item);
1621     nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_HEIGHT, &item);
1622     nodeAPI->setAttribute(rootNode, NODE_TEXT_LETTER_SPACING, &item);
1623 
1624     value[0].i32 = ARKUI_FONT_WEIGHT_W100;
1625     nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &item);
1626     value[0].i32 = ARKUI_FONT_STYLE_NORMAL;
1627     nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &item);
1628     value[0].i32 = ARKUI_TEXT_DECORATION_TYPE_NONE;
1629     nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &item);
1630     value[0].i32 = ARKUI_TEXT_CASE_NORMAL;
1631     nodeAPI->setAttribute(rootNode, NODE_TEXT_CASE, &item);
1632     item.string = "test";
1633     nodeAPI->setAttribute(rootNode, NODE_FONT_FAMILY, &item);
1634     nodeAPI->setAttribute(rootNode, NODE_SPAN_CONTENT, &item);
1635 
1636     nodeAPI->setAttribute(rootNode, NODE_TEXT_TEXT_SHADOW, &shadowItem);
1637     nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &backgroundStyleItem);
1638     backgroundStyle[2].f32 = -1.0f;
1639     nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &backgroundStyleItem);
1640     backgroundStyleItem.size = 2;
1641     nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &backgroundStyleItem);
1642     backgroundStyle[1].f32 = -1.0f;
1643     nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &backgroundStyleItem);
1644 
1645 
1646     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SPAN_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
1647     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
1648     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SPAN_BASELINE_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
1649     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1650     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_DECORATION), ARKUI_ERROR_CODE_NO_ERROR);
1651     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
1652     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
1653     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_WEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
1654     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_LINE_HEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
1655     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_CASE), ARKUI_ERROR_CODE_NO_ERROR);
1656     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_LETTER_SPACING), ARKUI_ERROR_CODE_NO_ERROR);
1657     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_FAMILY), ARKUI_ERROR_CODE_NO_ERROR);
1658     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_TEXT_SHADOW), ARKUI_ERROR_CODE_NO_ERROR);
1659 
1660     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH, nullptr), ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
1661     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_WIDTH), nullptr);
1662     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WIDTH), ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
1663 
1664     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SPAN_CONTENT), nullptr);
1665     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE), nullptr);
1666     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SPAN_BASELINE_OFFSET), nullptr);
1667     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_COLOR), nullptr);
1668     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_DECORATION), nullptr);
1669     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_SIZE), nullptr);
1670     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_STYLE), nullptr);
1671     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_WEIGHT), nullptr);
1672     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_LINE_HEIGHT), nullptr);
1673     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_CASE), nullptr);
1674     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_LETTER_SPACING), nullptr);
1675     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_FAMILY), nullptr);
1676     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_TEXT_SHADOW), nullptr);
1677     nodeAPI->disposeNode(rootNode);
1678 }
1679 
1680 /**
1681  * @tc.name: NativeNodeTest010
1682  * @tc.desc: Test imageSpanNode function.
1683  * @tc.type: FUNC
1684  */
1685 HWTEST_F(NativeNodeTest, NativeNodeTest010, TestSize.Level1)
1686 {
1687     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1688         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1689     auto rootNode = new ArkUI_Node({ARKUI_NODE_IMAGE_SPAN, nullptr, true});
1690     ArkUI_NumberValue value[] = {{.i32 = ARKUI_IMAGE_SPAN_ALIGNMENT_BASELINE}};
1691     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
1692     nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT, &item);
1693     item.string = "test";
1694     nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_SRC, &item);
1695     value[0].f32 = 10.0f;
1696     nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_BASELINE_OFFSET, &item);
1697 
1698     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_SPAN_SRC), ARKUI_ERROR_CODE_NO_ERROR);
1699     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT), ARKUI_ERROR_CODE_NO_ERROR);
1700     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_SPAN_ALT), ARKUI_ERROR_CODE_NO_ERROR);
1701     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_SPAN_BASELINE_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
1702 
1703     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_SPAN_SRC), nullptr);
1704     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT), nullptr);
1705     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_SPAN_ALT), nullptr);
1706     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_SPAN_BASELINE_OFFSET), nullptr);
1707     nodeAPI->disposeNode(rootNode);
1708 }
1709 
1710 /**
1711  * @tc.name: NativeNodeTest011
1712  * @tc.desc: Test imageNode function.
1713  * @tc.type: FUNC
1714  */
1715 HWTEST_F(NativeNodeTest, NativeNodeTest011, TestSize.Level1)
1716 {
1717     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1718         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1719     auto rootNode = new ArkUI_Node({ARKUI_NODE_IMAGE, nullptr, true});
1720 
1721     float border = 10.0f;
1722     ArkUI_NumberValue value[] = {{.f32 = border}};
1723     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
1724     ArkUI_NumberValue value20[] = {{.f32 = 1.0f}, {.f32 = 0.0f}, {.f32 = 0.0f}, {.f32 = 0.0f}, {.f32 = 0.0f},
1725         {.f32 = 0.0f}, {.f32 = 1.0f}, {.f32 = 0.0f}, {.f32 = 0.0f}, {.f32 = 0.0f},
1726         {.f32 = 0.0f}, {.f32 = 0.0f}, {.f32 = 1.0f}, {.f32 = 0.0f}, {.f32 = 0.0f},
1727         {.f32 = 0.0f}, {.f32 = 0.0f}, {.f32 = 0.0f}, {.f32 = 1.0f}, {.f32 = 0.0f}};
1728 
1729     ArkUI_AttributeItem item20 = {value20, sizeof(value20) / sizeof(ArkUI_NumberValue)};
1730     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item);
1731     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item);
1732     value[0].i32 = ARKUI_OBJECT_FIT_CONTAIN;
1733     nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_FIT, &item);
1734     value[0].i32 = ARKUI_IMAGE_INTERPOLATION_NONE;
1735     nodeAPI->setAttribute(rootNode, NODE_IMAGE_INTERPOLATION, &item);
1736     value[0].i32 = ARKUI_IMAGE_REPEAT_X;
1737     nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT, &item);
1738     value[0].i32 = ARKUI_IMAGE_RENDER_MODE_ORIGINAL;
1739     nodeAPI->setAttribute(rootNode, NODE_IMAGE_RENDER_MODE, &item);
1740     value[0].i32 = 1;
1741     nodeAPI->setAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE, &item);
1742 
1743     value[0].i32 = true;
1744     nodeAPI->setAttribute(rootNode, NODE_IMAGE_AUTO_RESIZE, &item);
1745     nodeAPI->setAttribute(rootNode, NODE_IMAGE_RESIZABLE, &item);
1746     nodeAPI->setAttribute(rootNode, NODE_IMAGE_DRAGGABLE, &item);
1747 
1748     value[0].u32 = 0xFFFF0000;
1749     nodeAPI->setAttribute(rootNode, NODE_IMAGE_FILL_COLOR, &item);
1750 
1751     item.string = "test";
1752     nodeAPI->setAttribute(rootNode, NODE_IMAGE_SRC, &item);
1753     nodeAPI->setAttribute(rootNode, NODE_IMAGE_ALT, &item);
1754 
1755     nodeAPI->setAttribute(rootNode, NODE_IMAGE_COLOR_FILTER, &item20);
1756 
1757     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_SRC), ARKUI_ERROR_CODE_NO_ERROR);
1758     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_OBJECT_FIT), ARKUI_ERROR_CODE_NO_ERROR);
1759     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_INTERPOLATION), ARKUI_ERROR_CODE_NO_ERROR);
1760     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT), ARKUI_ERROR_CODE_NO_ERROR);
1761     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_COLOR_FILTER), ARKUI_ERROR_CODE_NO_ERROR);
1762     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_AUTO_RESIZE), ARKUI_ERROR_CODE_NO_ERROR);
1763     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ALT), ARKUI_ERROR_CODE_NO_ERROR);
1764     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_DRAGGABLE), ARKUI_ERROR_CODE_NO_ERROR);
1765     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_RENDER_MODE), ARKUI_ERROR_CODE_NO_ERROR);
1766     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
1767     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_FILL_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1768     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_RESIZABLE), ARKUI_ERROR_CODE_NO_ERROR);
1769     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_RADIUS), ARKUI_ERROR_CODE_NO_ERROR);
1770     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT), ARKUI_ERROR_CODE_NO_ERROR);
1771 
1772     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_SRC), nullptr);
1773     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_OBJECT_FIT), nullptr);
1774     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_INTERPOLATION), nullptr);
1775     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT), nullptr);
1776     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_COLOR_FILTER), nullptr);
1777     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_AUTO_RESIZE), nullptr);
1778     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ALT), nullptr);
1779     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_DRAGGABLE), nullptr);
1780     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_RENDER_MODE), nullptr);
1781     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_FILL_COLOR), nullptr);
1782     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_RESIZABLE), nullptr);
1783     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE), nullptr);
1784     nodeAPI->disposeNode(rootNode);
1785 }
1786 
1787 /**
1788  * @tc.name: NativeNodeTest012
1789  * @tc.desc: Test toggleNode function.
1790  * @tc.type: FUNC
1791  */
1792 HWTEST_F(NativeNodeTest, NativeNodeTest012, TestSize.Level1)
1793 {
1794     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1795         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1796     auto rootNode = nodeAPI->createNode(ARKUI_NODE_TOGGLE);
1797     ASSERT_NE(rootNode, nullptr);
1798     uint32_t color = 0XFFFF0000;
1799     ArkUI_NumberValue value[] = {{.u32 = color}};
1800     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
1801     nodeAPI->setAttribute(rootNode, NODE_TOGGLE_SELECTED_COLOR, &item);
1802     nodeAPI->setAttribute(rootNode, NODE_TOGGLE_SWITCH_POINT_COLOR, &item);
1803     nodeAPI->setAttribute(rootNode, NODE_TOGGLE_VALUE, &item);
1804     nodeAPI->setAttribute(rootNode, NODE_TOGGLE_UNSELECTED_COLOR, &item);
1805     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TOGGLE_SELECTED_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1806     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TOGGLE_SWITCH_POINT_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1807     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TOGGLE_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
1808     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TOGGLE_UNSELECTED_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1809 
1810     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TOGGLE_SELECTED_COLOR), nullptr);
1811     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TOGGLE_SWITCH_POINT_COLOR), nullptr);
1812     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TOGGLE_VALUE), nullptr);
1813     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TOGGLE_UNSELECTED_COLOR), nullptr);
1814     nodeAPI->disposeNode(rootNode);
1815 }
1816 
1817 /**
1818  * @tc.name: NativeNodeTest013
1819  * @tc.desc: Test loadingProgressNode function.
1820  * @tc.type: FUNC
1821  */
1822 HWTEST_F(NativeNodeTest, NativeNodeTest013, TestSize.Level1)
1823 {
1824     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1825         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1826     auto rootNode = new ArkUI_Node({ARKUI_NODE_LOADING_PROGRESS, nullptr, true});
1827     ASSERT_NE(rootNode, nullptr);
1828     uint32_t color = 0XFFFF0000;
1829     ArkUI_NumberValue value[] = {{.u32 = color}};
1830     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
1831     nodeAPI->setAttribute(rootNode, NODE_LOADING_PROGRESS_COLOR, &item);
1832     value[0].i32 = true;
1833     nodeAPI->setAttribute(rootNode, NODE_LOADING_PROGRESS_ENABLE_LOADING, &item);
1834     value[0].i32 = -1;
1835     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LOADING_PROGRESS_ENABLE_LOADING, &item),
1836         ARKUI_ERROR_CODE_PARAM_INVALID);
1837     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LOADING_PROGRESS_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1838     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LOADING_PROGRESS_ENABLE_LOADING), ARKUI_ERROR_CODE_NO_ERROR);
1839 
1840     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LOADING_PROGRESS_COLOR), nullptr);
1841     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LOADING_PROGRESS_ENABLE_LOADING), nullptr);
1842     nodeAPI->disposeNode(rootNode);
1843 }
1844 
1845 /**
1846  * @tc.name: NativeNodeTest014
1847  * @tc.desc: Test textinputNode function.
1848  * @tc.type: FUNC
1849  */
1850 HWTEST_F(NativeNodeTest, NativeNodeTest014, TestSize.Level1)
1851 {
1852     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
1853         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
1854     auto rootNode = new ArkUI_Node({ARKUI_NODE_TEXT_INPUT, nullptr, true});
1855     uint32_t color = 0XFFFF0000;
1856     float padding = 10.0f;
1857     ArkUI_NumberValue value[] = {{.u32 = color}};
1858     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
1859     ArkUI_NumberValue value4[] = {{.u32 = color}, {.u32 = color}, {.u32 = color}, {.u32 = color}};
1860     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue)};
1861     ArkUI_NumberValue fontValue[] = {{.f32 = padding}, {.i32 = ARKUI_FONT_STYLE_NORMAL},
1862         {.i32 = ARKUI_FONT_WEIGHT_W100}};
1863     ArkUI_AttributeItem fontItem = {fontValue, sizeof(fontValue) / sizeof(ArkUI_NumberValue)};
1864     ArkUI_NumberValue cancelBtn[] = {{.i32 = ARKUI_CANCELBUTTON_STYLE_CONSTANT}, {.f32 = padding}, {.u32 = color}};
1865     ArkUI_AttributeItem cancelBtnItem = {cancelBtn, sizeof(cancelBtn) / sizeof(ArkUI_NumberValue)};
1866     ArkUI_NumberValue selection[] = {{.i32 = 0}, {.i32 = 1}};
1867     ArkUI_AttributeItem selectionItem = {selection, sizeof(selection) / sizeof(ArkUI_NumberValue)};
1868     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_COLOR, &item);
1869     nodeAPI->setAttribute(rootNode, NODE_BORDER_COLOR, &item);
1870     nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item);
1871     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CARET_COLOR, &item);
1872     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_COLOR, &item);
1873     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_SELECTED_BACKGROUND_COLOR, &item);
1874     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_UNDERLINE_COLOR, &item4);
1875     value[0].f32 = padding;
1876     nodeAPI->setAttribute(rootNode, NODE_PADDING, &item);
1877     nodeAPI->setAttribute(rootNode, NODE_MARGIN, &item);
1878     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item);
1879     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item);
1880     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item);
1881     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item);
1882     nodeAPI->setAttribute(rootNode, NODE_MARGIN_PERCENT, &item);
1883     nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item);
1884     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CARET_STYLE, &item);
1885     nodeAPI->setAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE, &item);
1886     nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE, &item);
1887     nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_HEIGHT, &item);
1888     value[0].i32 = ARKUI_BORDER_STYLE_SOLID;
1889     nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &item);
1890     value[0].i32 = ARKUI_FONT_WEIGHT_W100;
1891     nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &item);
1892     value[0].i32 = ARKUI_FONT_STYLE_NORMAL;
1893     nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &item);
1894     value[0].i32 = true;
1895     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_SHOW_UNDERLINE, &item);
1896     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_MAX_LENGTH, &item);
1897     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, &item);
1898     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, &item);
1899     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_EDITING, &item);
1900     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_SELECTION_MENU_HIDDEN, &item);
1901     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_AUTO_FILL, &item);
1902     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_SELECT_ALL, &item);
1903     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CARET_OFFSET, &item);
1904     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_NUMBER_OF_LINES, &item);
1905     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_BLUR_ON_SUBMIT, &item);
1906     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_SHOW_KEYBOARD_ON_FOCUS, &item);
1907     nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_LINES, &item);
1908     value[0].i32 = false;
1909     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_EDITING, &item);
1910     value[0].i32 = ARKUI_ENTER_KEY_TYPE_GO;
1911     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_ENTER_KEY_TYPE, &item);
1912     value[0].i32 = ARKUI_TEXTINPUT_TYPE_NORMAL;
1913     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_TYPE, &item);
1914     value[0].i32 = ARKUI_TEXTINPUT_CONTENT_TYPE_USER_NAME;
1915     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CONTENT_TYPE, &item);
1916     value[0].i32 = ARKUI_TEXTINPUT_CONTENT_TYPE_FORMAT_ADDRESS;
1917     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CONTENT_TYPE, &item);
1918     value[0].i32 = ARKUI_TEXTINPUT_STYLE_DEFAULT;
1919     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_STYLE, &item);
1920     value[0].i32 = ARKUI_WORD_BREAK_NORMAL;
1921     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_WORD_BREAK, &item);
1922     value[0].i32 = ARKUI_TEXT_ALIGNMENT_START;
1923     nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &item);
1924     item.string = "test";
1925     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER, &item);
1926     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_TEXT, &item);
1927     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_PASSWORD_RULES, &item);
1928     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_INPUT_FILTER, &item);
1929     nodeAPI->setAttribute(rootNode, NODE_FONT_FAMILY, &item);
1930     nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT_FEATURE, &item);
1931     item.object = rootNode;
1932     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CUSTOM_KEYBOARD, &item);
1933 
1934     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &fontItem);
1935     cancelBtnItem.size = 1;
1936     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CANCEL_BUTTON, &cancelBtnItem);
1937     cancelBtnItem.size = 2;
1938     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CANCEL_BUTTON, &cancelBtnItem);
1939     cancelBtnItem.size = sizeof(cancelBtn) / sizeof(ArkUI_NumberValue);
1940     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CANCEL_BUTTON, &cancelBtnItem);
1941     cancelBtnItem.string = "test";
1942     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CANCEL_BUTTON, &cancelBtnItem);
1943     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_TEXT_SELECTION, &selectionItem);
1944     selection[0].i32 = 2;
1945     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_TEXT_SELECTION, &selectionItem),
1946         ARKUI_ERROR_CODE_PARAM_INVALID);
1947     value[0].f32 = 50;
1948     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_LETTER_SPACING, &item);
1949     value[0].i32 = false;
1950     nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_PREVIEW_TEXT, &item);
1951     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER), ARKUI_ERROR_CODE_NO_ERROR);
1952     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_TEXT), ARKUI_ERROR_CODE_NO_ERROR);
1953     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_CARET_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1954     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_CARET_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
1955     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_SHOW_UNDERLINE), ARKUI_ERROR_CODE_NO_ERROR);
1956     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_MAX_LENGTH), ARKUI_ERROR_CODE_NO_ERROR);
1957     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_ENTER_KEY_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
1958     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1959     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_FONT), ARKUI_ERROR_CODE_NO_ERROR);
1960     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS), ARKUI_ERROR_CODE_NO_ERROR);
1961     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
1962     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_SELECTED_BACKGROUND_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1963     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON), ARKUI_ERROR_CODE_NO_ERROR);
1964     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_CANCEL_BUTTON), ARKUI_ERROR_CODE_NO_ERROR);
1965     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_TEXT_SELECTION), ARKUI_ERROR_CODE_NO_ERROR);
1966     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_UNDERLINE_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1967     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_AUTO_FILL), ARKUI_ERROR_CODE_NO_ERROR);
1968     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_CONTENT_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
1969     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_PASSWORD_RULES), ARKUI_ERROR_CODE_NO_ERROR);
1970     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_SELECT_ALL), ARKUI_ERROR_CODE_NO_ERROR);
1971     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_INPUT_FILTER), ARKUI_ERROR_CODE_NO_ERROR);
1972     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
1973     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_CARET_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
1974     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_SELECTION_MENU_HIDDEN), ARKUI_ERROR_CODE_NO_ERROR);
1975     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_BLUR_ON_SUBMIT), ARKUI_ERROR_CODE_NO_ERROR);
1976     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_CUSTOM_KEYBOARD), ARKUI_ERROR_CODE_NO_ERROR);
1977     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_WORD_BREAK), ARKUI_ERROR_CODE_NO_ERROR);
1978     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_SHOW_KEYBOARD_ON_FOCUS), ARKUI_ERROR_CODE_NO_ERROR);
1979     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_NUMBER_OF_LINES), ARKUI_ERROR_CODE_NO_ERROR);
1980     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1981     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_PADDING), ARKUI_ERROR_CODE_NO_ERROR);
1982     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_MARGIN), ARKUI_ERROR_CODE_NO_ERROR);
1983     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
1984     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_RADIUS), ARKUI_ERROR_CODE_NO_ERROR);
1985     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1986     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
1987     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
1988     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
1989     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
1990     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_WEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
1991     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_FAMILY), ARKUI_ERROR_CODE_NO_ERROR);
1992     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
1993     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
1994     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_LINE_HEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
1995     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MAX_LINES), ARKUI_ERROR_CODE_NO_ERROR);
1996     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_ALIGN), ARKUI_ERROR_CODE_NO_ERROR);
1997     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_FONT_FEATURE), ARKUI_ERROR_CODE_NO_ERROR);
1998     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_LETTER_SPACING), ARKUI_ERROR_CODE_NO_ERROR);
1999     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_PREVIEW_TEXT), ARKUI_ERROR_CODE_NO_ERROR);
2000 
2001     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER), nullptr);
2002     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_TEXT), nullptr);
2003     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_CARET_COLOR), nullptr);
2004     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_CARET_STYLE), nullptr);
2005     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_SHOW_UNDERLINE), nullptr);
2006     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_MAX_LENGTH), nullptr);
2007     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_ENTER_KEY_TYPE), nullptr);
2008     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_COLOR), nullptr);
2009     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_FONT), nullptr);
2010     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS), nullptr);
2011     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_TYPE), nullptr);
2012     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_SELECTED_BACKGROUND_COLOR), nullptr);
2013     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON), nullptr);
2014     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_EDITING), nullptr);
2015     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_CANCEL_BUTTON), nullptr);
2016     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_TEXT_SELECTION), nullptr);
2017     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_UNDERLINE_COLOR), nullptr);
2018     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_AUTO_FILL), nullptr);
2019     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_CONTENT_TYPE), nullptr);
2020     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_PASSWORD_RULES), nullptr);
2021     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_SELECT_ALL), nullptr);
2022     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_INPUT_FILTER), nullptr);
2023     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_STYLE), nullptr);
2024     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_CARET_OFFSET), nullptr);
2025     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_CONTENT_RECT), nullptr);
2026     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_CONTENT_LINE_COUNT), nullptr);
2027     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_SELECTION_MENU_HIDDEN), nullptr);
2028     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_BLUR_ON_SUBMIT), nullptr);
2029     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_CUSTOM_KEYBOARD), nullptr);
2030     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_WORD_BREAK), nullptr);
2031     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_SHOW_KEYBOARD_ON_FOCUS), nullptr);
2032     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_NUMBER_OF_LINES), nullptr);
2033     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_COLOR), nullptr);
2034     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_PADDING), nullptr);
2035     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_MARGIN), nullptr);
2036     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BORDER_WIDTH), nullptr);
2037     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BORDER_RADIUS), nullptr);
2038     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BORDER_COLOR), nullptr);
2039     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BORDER_STYLE), nullptr);
2040     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_COLOR), nullptr);
2041     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_SIZE), nullptr);
2042     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_STYLE), nullptr);
2043     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_WEIGHT), nullptr);
2044     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_FAMILY), nullptr);
2045     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE), nullptr);
2046     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE), nullptr);
2047     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_LINE_HEIGHT), nullptr);
2048     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MAX_LINES), nullptr);
2049     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_ALIGN), nullptr);
2050     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_FONT_FEATURE), nullptr);
2051     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_LETTER_SPACING), nullptr);
2052     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_PREVIEW_TEXT), nullptr);
2053     nodeAPI->disposeNode(rootNode);
2054 }
2055 
2056 /**
2057  * @tc.name: NativeNodeTest015
2058  * @tc.desc: Test textareaNode function.
2059  * @tc.type: FUNC
2060  */
2061 HWTEST_F(NativeNodeTest, NativeNodeTest015, TestSize.Level1)
2062 {
2063     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2064         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2065     auto rootNode = new ArkUI_Node({ARKUI_NODE_TEXT_AREA, nullptr, true});
2066     uint32_t color = 0XFFFF0000;
2067     float padding = 10.0f;
2068     ArkUI_NumberValue value[] = {{.u32 = color}};
2069     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
2070     ArkUI_NumberValue fontValue[] = {{.f32 = padding}, {.i32 = ARKUI_FONT_STYLE_NORMAL},
2071         {.i32 = ARKUI_FONT_WEIGHT_W100}};
2072     ArkUI_AttributeItem fontItem = {fontValue, sizeof(fontValue) / sizeof(ArkUI_NumberValue)};
2073     ArkUI_NumberValue showCounter[] = {{.i32 = true}, {.f32 = 50}, {.i32 = true}};
2074     ArkUI_AttributeItem showCounterItem = {fontValue, sizeof(showCounter) / sizeof(ArkUI_NumberValue)};
2075     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_COLOR, &item);
2076     nodeAPI->setAttribute(rootNode, NODE_BORDER_COLOR, &item);
2077     nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item);
2078     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_CARET_COLOR, &item);
2079     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER_COLOR, &item);
2080     value[0].f32 = padding;
2081     nodeAPI->setAttribute(rootNode, NODE_PADDING, &item);
2082     nodeAPI->setAttribute(rootNode, NODE_MARGIN, &item);
2083     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item);
2084     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item);
2085     nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item);
2086     nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item);
2087     nodeAPI->setAttribute(rootNode, NODE_MARGIN_PERCENT, &item);
2088     nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item);
2089     nodeAPI->setAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE, &item);
2090     nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE, &item);
2091     nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_HEIGHT, &item);
2092     value[0].i32 = ARKUI_BORDER_STYLE_SOLID;
2093     nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &item);
2094     value[0].i32 = ARKUI_FONT_WEIGHT_W100;
2095     nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &item);
2096     value[0].i32 = ARKUI_FONT_STYLE_NORMAL;
2097     nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &item);
2098     value[0].i32 = ARKUI_TEXTAREA_TYPE_NORMAL;
2099     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_TYPE, &item);
2100     value[0].i32 = ARKUI_TEXT_ALIGNMENT_START;
2101     nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &item);
2102     value[0].i32 = true;
2103     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_MAX_LENGTH, &item);
2104     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_EDITING, &item);
2105     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_SELECTION_MENU_HIDDEN, &item);
2106     nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_LINES, &item);
2107     value[0].i32 = false;
2108     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_EDITING, &item);
2109 
2110     item.string = "test";
2111     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER, &item);
2112     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_TEXT, &item);
2113     nodeAPI->setAttribute(rootNode, NODE_FONT_FAMILY, &item);
2114     nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT_FEATURE, &item);
2115 
2116     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER_FONT, &fontItem);
2117     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_SHOW_COUNTER, &showCounterItem);
2118     value[0].f32 = 50;
2119     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_LETTER_SPACING, &item);
2120     value[0].i32 = false;
2121     nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_ENABLE_PREVIEW_TEXT, &item);
2122     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER), ARKUI_ERROR_CODE_NO_ERROR);
2123     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_TEXT), ARKUI_ERROR_CODE_NO_ERROR);
2124     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_MAX_LENGTH), ARKUI_ERROR_CODE_NO_ERROR);
2125     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2126     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER_FONT), ARKUI_ERROR_CODE_NO_ERROR);
2127     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_CARET_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2128     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
2129     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_SHOW_COUNTER), ARKUI_ERROR_CODE_NO_ERROR);
2130     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_SELECTION_MENU_HIDDEN), ARKUI_ERROR_CODE_NO_ERROR);
2131     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_BLUR_ON_SUBMIT), ARKUI_ERROR_CODE_NO_ERROR);
2132     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_INPUT_FILTER), ARKUI_ERROR_CODE_NO_ERROR);
2133     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_SELECTED_BACKGROUND_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2134     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_ENTER_KEY_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
2135     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_ENABLE_KEYBOARD_ON_FOCUS), ARKUI_ERROR_CODE_NO_ERROR);
2136     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_CARET_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
2137     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_TEXT_SELECTION), ARKUI_ERROR_CODE_NO_ERROR);
2138     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_ENABLE_AUTO_FILL), ARKUI_ERROR_CODE_NO_ERROR);
2139     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_CONTENT_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
2140     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_SHOW_KEYBOARD_ON_FOCUS), ARKUI_ERROR_CODE_NO_ERROR);
2141     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_NUMBER_OF_LINES), ARKUI_ERROR_CODE_NO_ERROR);
2142     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2143     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_MARGIN), ARKUI_ERROR_CODE_NO_ERROR);
2144     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
2145     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_RADIUS), ARKUI_ERROR_CODE_NO_ERROR);
2146     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2147     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BORDER_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2148     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2149     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
2150     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2151     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_WEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
2152     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_FAMILY), ARKUI_ERROR_CODE_NO_ERROR);
2153     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
2154     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
2155     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_LINE_HEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
2156     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_MAX_LINES), ARKUI_ERROR_CODE_NO_ERROR);
2157     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_ALIGN), ARKUI_ERROR_CODE_NO_ERROR);
2158     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_FONT_FEATURE), ARKUI_ERROR_CODE_NO_ERROR);
2159     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_LETTER_SPACING), ARKUI_ERROR_CODE_NO_ERROR);
2160     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_AREA_ENABLE_PREVIEW_TEXT), ARKUI_ERROR_CODE_NO_ERROR);
2161 
2162     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER), nullptr);
2163     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_TEXT), nullptr);
2164     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_MAX_LENGTH), nullptr);
2165     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER_COLOR), nullptr);
2166     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER_FONT), nullptr);
2167     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_CARET_COLOR), nullptr);
2168     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_EDITING), nullptr);
2169     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_TYPE), nullptr);
2170     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_SHOW_COUNTER), nullptr);
2171     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_SELECTION_MENU_HIDDEN), nullptr);
2172     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_BLUR_ON_SUBMIT), nullptr);
2173     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_INPUT_FILTER), nullptr);
2174     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_SELECTED_BACKGROUND_COLOR), nullptr);
2175     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_ENTER_KEY_TYPE), nullptr);
2176     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_ENABLE_KEYBOARD_ON_FOCUS), nullptr);
2177     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_CARET_OFFSET), nullptr);
2178     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_CONTENT_RECT), nullptr);
2179     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_CONTENT_LINE_COUNT), nullptr);
2180     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_TEXT_SELECTION), nullptr);
2181     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_ENABLE_AUTO_FILL), nullptr);
2182     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_CONTENT_TYPE), nullptr);
2183     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_SHOW_KEYBOARD_ON_FOCUS), nullptr);
2184     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_NUMBER_OF_LINES), nullptr);
2185     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_COLOR), nullptr);
2186     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_PADDING), nullptr);
2187     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_MARGIN), nullptr);
2188     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BORDER_WIDTH), nullptr);
2189     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BORDER_RADIUS), nullptr);
2190     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BORDER_COLOR), nullptr);
2191     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BORDER_STYLE), nullptr);
2192     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_COLOR), nullptr);
2193     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_SIZE), nullptr);
2194     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_STYLE), nullptr);
2195     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_WEIGHT), nullptr);
2196     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_FAMILY), nullptr);
2197     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE), nullptr);
2198     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE), nullptr);
2199     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_LINE_HEIGHT), nullptr);
2200     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_MAX_LINES), nullptr);
2201     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_ALIGN), nullptr);
2202     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_FONT_FEATURE), nullptr);
2203     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_LETTER_SPACING), nullptr);
2204     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_AREA_ENABLE_PREVIEW_TEXT), nullptr);
2205     nodeAPI->disposeNode(rootNode);
2206 }
2207 
2208 /**
2209  * @tc.name: NativeNodeTest016
2210  * @tc.desc: Test buttonNode function.
2211  * @tc.type: FUNC
2212  */
2213 HWTEST_F(NativeNodeTest, NativeNodeTest016, TestSize.Level1)
2214 {
2215     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2216         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2217     auto rootNode = new ArkUI_Node({ARKUI_NODE_BUTTON, nullptr, true});
2218     ArkUI_NumberValue value[] = {{.f32 = 10.0f}};
2219     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test", nullptr};
2220     nodeAPI->setAttribute(rootNode, NODE_BUTTON_LABEL, &item);
2221     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BUTTON_LABEL), nullptr);
2222     nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item);
2223     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_SIZE), nullptr);
2224     value[0].i32 = ARKUI_BUTTON_TYPE_NORMAL;
2225     nodeAPI->setAttribute(rootNode, NODE_BUTTON_TYPE, &item);
2226     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BUTTON_TYPE), nullptr);
2227     value[0].i32 = ARKUI_FONT_WEIGHT_W100;
2228     nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &item);
2229     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_WEIGHT), nullptr);
2230     value[0].u32 = 0xFFFF0000;
2231     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_COLOR, &item);
2232     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_COLOR), nullptr);
2233     nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item);
2234     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FONT_COLOR), nullptr);
2235 
2236     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BUTTON_LABEL), ARKUI_ERROR_CODE_NO_ERROR);
2237     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BUTTON_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
2238     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_BACKGROUND_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2239     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2240     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
2241     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FONT_WEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
2242     nodeAPI->disposeNode(rootNode);
2243 }
2244 
2245 /**
2246  * @tc.name: NativeNodeTest017
2247  * @tc.desc: Test progressNode function.
2248  * @tc.type: FUNC
2249  */
2250 HWTEST_F(NativeNodeTest, NativeNodeTest017, TestSize.Level1)
2251 {
2252     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2253         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2254     auto rootNode = nodeAPI->createNode(ARKUI_NODE_PROGRESS);
2255     ASSERT_NE(rootNode, nullptr);
2256     ArkUI_NumberValue value[] = {{.f32 = 10.0f}};
2257     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
2258     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_VALUE, &item);
2259     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TOTAL, &item);
2260     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_COLOR, &item);
2261     value[0].i32 = ARKUI_PROGRESS_TYPE_LINEAR;
2262     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TYPE, &item);
2263     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_PROGRESS_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2264     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_PROGRESS_TOTAL), ARKUI_ERROR_CODE_NO_ERROR);
2265     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_PROGRESS_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2266     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_PROGRESS_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
2267 
2268     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_PROGRESS_VALUE), nullptr);
2269     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_PROGRESS_TOTAL), nullptr);
2270     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_PROGRESS_COLOR), nullptr);
2271     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_PROGRESS_TYPE), nullptr);
2272     nodeAPI->disposeNode(rootNode);
2273 }
2274 
2275 /**
2276  * @tc.name: NativeNodeTest018
2277  * @tc.desc: Test checkboxNode function.
2278  * @tc.type: FUNC
2279  */
2280 HWTEST_F(NativeNodeTest, NativeNodeTest018, TestSize.Level1)
2281 {
2282     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2283         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2284     auto rootNode = nodeAPI->createNode(ARKUI_NODE_CHECKBOX);
2285     ASSERT_NE(rootNode, nullptr);
2286     float size = 10.0f;
2287     uint32_t color = 0xFFFF0000;
2288     ArkUI_NumberValue value[] = {{.i32 = true}};
2289     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
2290     ArkUI_NumberValue mark[] = {{.u32 = color}, {.f32 = size}, {.f32 = size}};
2291     ArkUI_AttributeItem markItem = {mark, sizeof(mark) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2292     nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SELECT, &item);
2293     value[0].u32 = color;
2294     nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SELECT_COLOR, &item);
2295     nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_UNSELECT_COLOR, &item);
2296     nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_MARK, &item);
2297     value[0].i32 = ArkUI_CHECKBOX_SHAPE_CIRCLE;
2298     nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SHAPE, &item);
2299     nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_MARK, &markItem);
2300     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CHECKBOX_SELECT), ARKUI_ERROR_CODE_NO_ERROR);
2301     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CHECKBOX_SELECT_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2302     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CHECKBOX_UNSELECT_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2303     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CHECKBOX_MARK), ARKUI_ERROR_CODE_NO_ERROR);
2304     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CHECKBOX_SHAPE), ARKUI_ERROR_CODE_NO_ERROR);
2305 
2306     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CHECKBOX_SELECT), nullptr);
2307     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CHECKBOX_SELECT_COLOR), nullptr);
2308     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CHECKBOX_UNSELECT_COLOR), nullptr);
2309     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CHECKBOX_MARK), nullptr);
2310     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CHECKBOX_SHAPE), nullptr);
2311     nodeAPI->disposeNode(rootNode);
2312 }
2313 
2314 /**
2315  * @tc.name: NativeNodeTest019
2316  * @tc.desc: Test xcomponentNode function.
2317  * @tc.type: FUNC
2318  */
2319 HWTEST_F(NativeNodeTest, NativeNodeTest019, TestSize.Level1)
2320 {
2321     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2322         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2323     auto rootNode = nodeAPI->createNode(ARKUI_NODE_XCOMPONENT);
2324     ASSERT_NE(rootNode, nullptr);
2325 
2326     ArkUI_NumberValue value[] = {{.i32 = ARKUI_XCOMPONENT_TYPE_SURFACE}, {.f32 = 10.0f}};
2327     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"};
2328     nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_ID, &item);
2329     nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item);
2330     value[0].i32 = ARKUI_XCOMPONENT_TYPE_TEXTURE;
2331     nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item);
2332 
2333     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_XCOMPONENT_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
2334 
2335     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_XCOMPONENT_ID), nullptr);
2336     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_XCOMPONENT_TYPE), nullptr);
2337     nodeAPI->disposeNode(rootNode);
2338 }
2339 
2340 /**
2341  * @tc.name: NativeNodeTest020
2342  * @tc.desc: Test datePickerNode function.
2343  * @tc.type: FUNC
2344  */
2345 HWTEST_F(NativeNodeTest, NativeNodeTest020, TestSize.Level1)
2346 {
2347     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2348         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2349 
2350     auto rootNode = new ArkUI_Node({ARKUI_NODE_DATE_PICKER, nullptr, true});
2351     ArkUI_NumberValue value[] = {{.i32 = true}};
2352     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2353     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_LUNAR, &item);
2354     item.string = "1970-1-1";
2355     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_START, &item);
2356     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_END, &item);
2357     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED, &item);
2358     item.string = "#ff182431;14;normal;Arial;normal";
2359     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item);
2360     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE, &item);
2361     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
2362         ARKUI_ERROR_CODE_NO_ERROR);
2363     item.string = "#ff182431;14;normal;Arial;test";
2364     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
2365         ARKUI_ERROR_CODE_NO_ERROR);
2366     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_LUNAR), ARKUI_ERROR_CODE_NO_ERROR);
2367     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_START), ARKUI_ERROR_CODE_NO_ERROR);
2368     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_END), ARKUI_ERROR_CODE_NO_ERROR);
2369     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_SELECTED), ARKUI_ERROR_CODE_NO_ERROR);
2370     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2371     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2372     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2373 
2374     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_LUNAR), nullptr);
2375     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_START), nullptr);
2376     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_END), nullptr);
2377     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_SELECTED), nullptr);
2378     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE), nullptr);
2379     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE), nullptr);
2380     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE), nullptr);
2381     nodeAPI->disposeNode(rootNode);
2382 }
2383 
2384 /**
2385  * @tc.name: NativeNodeTest021
2386  * @tc.desc: Test timePickerNode function.
2387  * @tc.type: FUNC
2388  */
2389 HWTEST_F(NativeNodeTest, NativeNodeTest021, TestSize.Level1)
2390 {
2391     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2392         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2393     auto rootNode = new ArkUI_Node({ARKUI_NODE_TIME_PICKER, nullptr, true});
2394     ArkUI_NumberValue value[] = {{.i32 = true}};
2395     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2396     item.string = "11-59";
2397     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item);
2398     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_USE_MILITARY_TIME, &item);
2399     item.string = "#ff182431;14;normal;Arial;normal";
2400     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, &item);
2401     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE, &item);
2402     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item);
2403     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_SELECTED), ARKUI_ERROR_CODE_NO_ERROR);
2404     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_USE_MILITARY_TIME), ARKUI_ERROR_CODE_NO_ERROR);
2405     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2406     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2407     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2408 
2409     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_SELECTED), nullptr);
2410     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_USE_MILITARY_TIME), nullptr);
2411     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE), nullptr);
2412     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE), nullptr);
2413     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE), nullptr);
2414     nodeAPI->disposeNode(rootNode);
2415 }
2416 
2417 /**
2418  * @tc.name: NativeNodeTest022
2419  * @tc.desc: Test textPickerNode function.
2420  * @tc.type: FUNC
2421  */
2422 HWTEST_F(NativeNodeTest, NativeNodeTest022, TestSize.Level1)
2423 {
2424     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2425         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2426     auto rootNode = new ArkUI_Node({ARKUI_NODE_TEXT_PICKER, nullptr, true});
2427     ArkUI_NumberValue value[] = {{.i32 = ARKUI_TEXTPICKER_RANGETYPE_SINGLE}};
2428     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2429     item.string = "1;2;3";
2430     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE, &item);
2431     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_VALUE, &item);
2432     item.string = "#ff182431;14;normal;Arial;normal";
2433     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item);
2434     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE, &item);
2435     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item);
2436 
2437     value[0].u32 = 0;
2438     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_SELECTED, &item);
2439     value[0].i32 = 0;
2440     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_CAN_LOOP, &item);
2441     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_INDEX, &item);
2442 
2443     value[0].f32 = 10.0f;
2444     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DEFAULT_PICKER_ITEM_HEIGHT, &item);
2445     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE), ARKUI_ERROR_CODE_NO_ERROR);
2446     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_OPTION_SELECTED), ARKUI_ERROR_CODE_NO_ERROR);
2447     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_OPTION_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2448     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2449     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2450     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2451     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_INDEX), ARKUI_ERROR_CODE_NO_ERROR);
2452     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_CAN_LOOP), ARKUI_ERROR_CODE_NO_ERROR);
2453     EXPECT_EQ(nodeAPI->resetAttribute(
2454         rootNode, NODE_TEXT_PICKER_DEFAULT_PICKER_ITEM_HEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
2455 
2456     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE), nullptr);
2457     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_OPTION_SELECTED), nullptr);
2458     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_OPTION_VALUE), nullptr);
2459     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE), nullptr);
2460     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE), nullptr);
2461     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE), nullptr);
2462     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_INDEX), nullptr);
2463     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_CAN_LOOP), nullptr);
2464     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_DEFAULT_PICKER_ITEM_HEIGHT), nullptr);
2465     nodeAPI->disposeNode(rootNode);
2466 }
2467 
2468 /**
2469  * @tc.name: NativeNodeTest023
2470  * @tc.desc: Test calendarPickerNode function.
2471  * @tc.type: FUNC
2472  */
2473 HWTEST_F(NativeNodeTest, NativeNodeTest023, TestSize.Level1)
2474 {
2475     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2476         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2477     auto rootNode = new ArkUI_Node({ARKUI_NODE_CALENDAR_PICKER, nullptr, true});
2478     float offset = 10.0f;
2479     ArkUI_NumberValue value[] = {{.f32 = offset}};
2480     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2481     ArkUI_NumberValue value3[] = {{.u32 = 2024}, {.u32 = 1}, {.u32 = 1}};
2482     ArkUI_AttributeItem item3 = {value3, sizeof(value3) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2483     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS, &item);
2484     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE, &item3);
2485 
2486     value[0].i32 = ARKUI_CALENDAR_ALIGNMENT_START;
2487     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &item);
2488     value3[0].i32 = ARKUI_CALENDAR_ALIGNMENT_START;
2489     value3[1].f32 = offset;
2490     value3[2].f32 = offset;
2491     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &item3);
2492     value3[0].u32 = 0xFFFF0000;
2493     value3[1].f32 = offset;
2494     value3[2].i32 = ARKUI_FONT_WEIGHT_NORMAL;
2495     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item3);
2496     item3.size = -1;
2497     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item3), ARKUI_ERROR_CODE_PARAM_INVALID);
2498 
2499     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS), ARKUI_ERROR_CODE_NO_ERROR);
2500     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE), ARKUI_ERROR_CODE_NO_ERROR);
2501     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT), ARKUI_ERROR_CODE_NO_ERROR);
2502     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2503 
2504     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS), nullptr);
2505     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE), nullptr);
2506     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT), nullptr);
2507     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE), nullptr);
2508     nodeAPI->disposeNode(rootNode);
2509 }
2510 
2511 /**
2512  * @tc.name: NativeNodeTest024
2513  * @tc.desc: Test sliderNode function.
2514  * @tc.type: FUNC
2515  */
2516 HWTEST_F(NativeNodeTest, NativeNodeTest024, TestSize.Level1)
2517 {
2518     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2519         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2520     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SLIDER);
2521     ASSERT_NE(rootNode, nullptr);
2522     uint32_t color = 0xFFFF0000;
2523     float size = 10.0f;
2524     ArkUI_NumberValue value[] = {{.u32 = color}};
2525     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2526     ArkUI_NumberValue blockStyle[] = {{.i32 = ARKUI_SLIDER_BLOCK_STYLE_IMAGE }, {.i32 = ARKUI_CLIP_TYPE_PATH},
2527         {.f32 = size}, {.f32 = size}, {.f32 = size}};
2528     ArkUI_AttributeItem blockStyleItem = {blockStyle, sizeof(blockStyle) / sizeof(ArkUI_NumberValue), "test", nullptr};
2529     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_COLOR, &item);
2530     nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_COLOR, &item);
2531     nodeAPI->setAttribute(rootNode, NODE_SLIDER_SELECTED_COLOR, &item);
2532     value[0].i32 = true;
2533     nodeAPI->setAttribute(rootNode, NODE_SLIDER_SHOW_STEPS, &item);
2534     nodeAPI->setAttribute(rootNode, NODE_SLIDER_REVERSE, &item);
2535     value[0].i32 = ARKUI_SLIDER_DIRECTION_VERTICAL;
2536     nodeAPI->setAttribute(rootNode, NODE_SLIDER_DIRECTION, &item);
2537     value[0].i32 = ARKUI_SLIDER_STYLE_OUT_SET;
2538     nodeAPI->setAttribute(rootNode, NODE_SLIDER_STYLE, &item);
2539     value[0].f32 = size;
2540     nodeAPI->setAttribute(rootNode, NODE_SLIDER_VALUE, &item);
2541     nodeAPI->setAttribute(rootNode, NODE_SLIDER_MIN_VALUE, &item);
2542     nodeAPI->setAttribute(rootNode, NODE_SLIDER_MAX_VALUE, &item);
2543     nodeAPI->setAttribute(rootNode, NODE_SLIDER_STEP, &item);
2544     nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS, &item);
2545 
2546     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &blockStyleItem);
2547     blockStyle[0].i32 = ARKUI_SLIDER_BLOCK_STYLE_SHAPE;
2548     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &blockStyleItem);
2549     blockStyle[1].i32 = ARKUI_CLIP_TYPE_RECTANGLE;
2550     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &blockStyleItem);
2551     blockStyle[0].i32 = ARKUI_SLIDER_BLOCK_STYLE_DEFAULT;
2552     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &blockStyleItem);
2553     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_BLOCK_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2554     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_TRACK_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2555     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_SELECTED_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2556     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_SHOW_STEPS), ARKUI_ERROR_CODE_NO_ERROR);
2557     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2558     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2559     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_MIN_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2560     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_MAX_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2561     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_STEP), ARKUI_ERROR_CODE_NO_ERROR);
2562     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
2563     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_REVERSE), ARKUI_ERROR_CODE_NO_ERROR);
2564     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2565     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS), ARKUI_ERROR_CODE_NO_ERROR);
2566 
2567     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_BLOCK_COLOR), nullptr);
2568     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_SHOW_STEPS), nullptr);
2569     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE), nullptr);
2570     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_VALUE), nullptr);
2571     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_MIN_VALUE), nullptr);
2572     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_MAX_VALUE), nullptr);
2573     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_STEP), nullptr);
2574     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_DIRECTION), nullptr);
2575     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_REVERSE), nullptr);
2576     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_STYLE), nullptr);
2577     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS), nullptr);
2578     nodeAPI->disposeNode(rootNode);
2579 }
2580 
2581 /**
2582  * @tc.name: NativeNodeTest025
2583  * @tc.desc: Test radioNode function.
2584  * @tc.type: FUNC
2585  */
2586 HWTEST_F(NativeNodeTest, NativeNodeTest025, TestSize.Level1)
2587 {
2588     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2589         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2590     auto rootNode = nodeAPI->createNode(ARKUI_NODE_RADIO);
2591     ASSERT_NE(rootNode, nullptr);
2592     uint32_t color = 0xFFFF0000;
2593     ArkUI_NumberValue value[] = {{.i32 = true}};
2594     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2595     ArkUI_NumberValue style[] = {{.u32 = color}, {.u32 = color}, {.u32 = color}};
2596     ArkUI_AttributeItem styleItem = {style, sizeof(style) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2597     nodeAPI->setAttribute(rootNode, NODE_RADIO_CHECKED, &item);
2598     item.string = "test";
2599     nodeAPI->setAttribute(rootNode, NODE_RADIO_VALUE, &item);
2600     nodeAPI->setAttribute(rootNode, NODE_RADIO_GROUP, &item);
2601     nodeAPI->setAttribute(rootNode, NODE_RADIO_STYLE, &styleItem);
2602     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIO_CHECKED), ARKUI_ERROR_CODE_NO_ERROR);
2603     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIO_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2604     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIO_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2605     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIO_GROUP), ARKUI_ERROR_CODE_NO_ERROR);
2606 
2607     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_RADIO_CHECKED), nullptr);
2608     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_RADIO_STYLE), nullptr);
2609     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_RADIO_VALUE), nullptr);
2610     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_RADIO_GROUP), nullptr);
2611     nodeAPI->disposeNode(rootNode);
2612 }
2613 
2614 /**
2615  * @tc.name: NativeNodeTest026
2616  * @tc.desc: Test scrollNode function.
2617  * @tc.type: FUNC
2618  */
2619 HWTEST_F(NativeNodeTest, NativeNodeTest026, TestSize.Level1)
2620 {
2621     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2622         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2623     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SCROLL);
2624     ASSERT_NE(rootNode, nullptr);
2625     float distance = 10.0f;
2626     uint32_t color = 0xFFFF0000;
2627     ArkUI_NumberValue value[] = {{.f32 = distance}};
2628     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
2629     ArkUI_NumberValue value2[] = {{.i32 = true}, {.i32 = true}};
2630     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
2631     ArkUI_NumberValue scrollsnap[] = {{.i32 = ARKUI_SCROLL_SNAP_ALIGN_NONE}, {.i32 = true}, {.i32 = true},
2632         {.f32 = distance}};
2633     ArkUI_AttributeItem scrollsnapItem = {scrollsnap, sizeof(scrollsnap) / sizeof(ArkUI_NumberValue)};
2634     ArkUI_NumberValue scrollnested[] = {{.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY},
2635         {.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY}};
2636     ArkUI_AttributeItem scrollnestedItem = {scrollnested, sizeof(scrollnested) / sizeof(ArkUI_NumberValue)};
2637     ArkUI_NumberValue scrolloffset[] = {{.f32 = distance}, {.f32 = distance}, { .i32 = 1000},
2638         {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = true}};
2639     ArkUI_AttributeItem scrolloffsetItem = {scrolloffset, sizeof(scrolloffset) / sizeof(ArkUI_NumberValue)};
2640     nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item);
2641     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item);
2642 
2643     value[0].u32 = color;
2644     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item);
2645 
2646     value[0].i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO;
2647     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item);
2648     value[0].i32 = ARKUI_SCROLL_DIRECTION_VERTICAL;
2649     nodeAPI->setAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION, &item);
2650     value[0].i32 = ARKUI_EDGE_EFFECT_NONE;
2651     nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item);
2652     value[0].i32 = true;
2653     nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item);
2654     nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING, &item);
2655     nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item);
2656     value[0].i32 = ARKUI_SCROLL_EDGE_TOP;
2657     nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE, &item);
2658 
2659     nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &scrollsnapItem);
2660     nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &scrollnestedItem);
2661     scrolloffsetItem.size = 2;
2662     nodeAPI->setAttribute(rootNode, NODE_SCROLL_OFFSET, &scrolloffsetItem);
2663     scrolloffsetItem.size = sizeof(scrolloffset) / sizeof(ArkUI_NumberValue);
2664     nodeAPI->setAttribute(rootNode, NODE_SCROLL_OFFSET, &scrolloffsetItem);
2665     scrolloffset[3].i32 = -1;
2666     nodeAPI->setAttribute(rootNode, NODE_SCROLL_OFFSET, &scrolloffsetItem);
2667 
2668     nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item2);
2669     value2[1].i32 = -1;
2670     nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item2);
2671 
2672     value2[0].f32 = distance;
2673     value2[1].f32 = distance;
2674     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item2);
2675     nodeAPI->setLengthMetricUnit(rootNode, ARKUI_LENGTH_METRIC_UNIT_PX);
2676     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item2);
2677     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), ARKUI_ERROR_CODE_NO_ERROR);
2678     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
2679     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2680     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
2681     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), ARKUI_ERROR_CODE_NO_ERROR);
2682     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), ARKUI_ERROR_CODE_NO_ERROR);
2683     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_FRICTION), ARKUI_ERROR_CODE_NO_ERROR);
2684     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_SNAP), ARKUI_ERROR_CODE_NO_ERROR);
2685     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR);
2686     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
2687     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_EDGE), ARKUI_ERROR_CODE_NO_ERROR);
2688     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING), ARKUI_ERROR_CODE_NO_ERROR);
2689 
2690     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), nullptr);
2691     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), nullptr);
2692     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_COLOR), nullptr);
2693     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION), nullptr);
2694     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), nullptr);
2695     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), nullptr);
2696     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION), nullptr);
2697     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_SNAP), nullptr);
2698     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), nullptr);
2699     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_OFFSET), nullptr);
2700     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_EDGE), nullptr);
2701     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING), nullptr);
2702     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FLING_SPEED_LIMIT)->value->f32, 9000.0f);
2703     value[0].f32 = 100.0f;
2704     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_FLING_SPEED_LIMIT, &item), ARKUI_ERROR_CODE_NO_ERROR);
2705     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FLING_SPEED_LIMIT)->value->f32, 100.0f);
2706     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_FLING_SPEED_LIMIT), ARKUI_ERROR_CODE_NO_ERROR);
2707     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FLING_SPEED_LIMIT)->value->f32, 9000.0f);
2708 
2709     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_SCROLL_CLIP_CONTENT)->value->i32,
2710                                     ArkUI_ContentClipMode::ARKUI_CONTENT_CLIP_MODE_BOUNDARY);
2711 
2712     ArkUI_NumberValue clipValue[] = {{.i32 = ArkUI_ContentClipMode::ARKUI_CONTENT_CLIP_MODE_SAFE_AREA}};
2713     ArkUI_AttributeItem clipItem = {clipValue, sizeof(clipValue) / sizeof(ArkUI_NumberValue)};
2714     nodeAPI->setAttribute(rootNode, NODE_SCROLL_CLIP_CONTENT, &clipItem);
2715     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_SCROLL_CLIP_CONTENT)->value->i32,
2716                                     ArkUI_ContentClipMode::ARKUI_CONTENT_CLIP_MODE_SAFE_AREA);
2717     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_CLIP_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
2718     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_SCROLL_CLIP_CONTENT)->value->i32,
2719                                     ArkUI_ContentClipMode::ARKUI_CONTENT_CLIP_MODE_BOUNDARY);
2720     nodeAPI->disposeNode(rootNode);
2721 }
2722 
2723 /**
2724  * @tc.name: NativeNodeTest027
2725  * @tc.desc: Test listNode function.
2726  * @tc.type: FUNC
2727  */
2728 HWTEST_F(NativeNodeTest, NativeNodeTest027, TestSize.Level1)
2729 {
2730     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2731         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2732     auto rootNode = new ArkUI_Node({ARKUI_NODE_LIST, nullptr, true});
2733     auto childNode = new ArkUI_Node({ARKUI_NODE_LIST_ITEM, nullptr, true});
2734     auto groupNode = new ArkUI_Node({ARKUI_NODE_LIST_ITEM_GROUP, nullptr, true});
2735 
2736     float distance = 10.0f;
2737     uint32_t color = 0xFFFF0000;
2738     ArkUI_NumberValue value[] = {{.f32 = distance}};
2739     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
2740     ArkUI_NumberValue value2[] = {{.f32 = distance}, {.f32 = distance}};
2741     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
2742     ArkUI_NumberValue scrollnested[] = {{.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY},
2743         {.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY}};
2744     ArkUI_AttributeItem scrollnestedItem = {scrollnested, sizeof(scrollnested) / sizeof(ArkUI_NumberValue)};
2745     ArkUI_NumberValue scrollToIndex[] = {{.i32 = 0}, {.i32 = 1}, {.i32 = ARKUI_SCROLL_ALIGNMENT_START}};
2746     ArkUI_AttributeItem scrollToIndexItem = {scrollToIndex, sizeof(scrollToIndex) / sizeof(ArkUI_NumberValue)};
2747     ArkUI_NumberValue divider[] = {{.u32 = color}, {.f32 = distance}, {.f32 = distance}, {.f32 = distance}};
2748     ArkUI_AttributeItem dividerItem = {divider, sizeof(divider) / sizeof(ArkUI_NumberValue)};
2749     nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item);
2750     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item);
2751     value[0].u32 = color;
2752     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item);
2753 
2754     value[0].i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO;
2755     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item);
2756     value[0].i32 = ARKUI_EDGE_EFFECT_NONE;
2757     nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item);
2758     value[0].i32 = true;
2759     nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item);
2760     value[0].i32 = ARKUI_AXIS_VERTICAL;
2761     nodeAPI->setAttribute(rootNode, NODE_LIST_DIRECTION, &item);
2762     value[0].i32 = ARKUI_STICKY_STYLE_NONE;
2763     nodeAPI->setAttribute(rootNode, NODE_LIST_STICKY, &item);
2764     value[0].i32 = 1;
2765     nodeAPI->setAttribute(rootNode, NODE_LIST_SPACE, &item);
2766     nodeAPI->setAttribute(rootNode, NODE_LIST_CACHED_COUNT, &item);
2767     value[0].i32 = ARKUI_LIST_ITEM_ALIGNMENT_START;
2768     nodeAPI->setAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM, &item);
2769     value[0].i32 = 0;
2770     nodeAPI->setAttribute(rootNode, NODE_LIST_SCROLL_TO_INDEX, &item);
2771     nodeAPI->setAttribute(rootNode, NODE_LIST_INITIAL_INDEX, &item);
2772     item.object = rootNode;
2773     nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_HEADER, &item);
2774     nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_FOOTER, &item);
2775 
2776     nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &scrollnestedItem);
2777 
2778     nodeAPI->setAttribute(rootNode, NODE_LIST_SCROLL_TO_INDEX, &scrollToIndexItem);
2779     scrollToIndex[2].i32 = ARKUI_SCROLL_ALIGNMENT_NONE;
2780     nodeAPI->setAttribute(rootNode, NODE_LIST_SCROLL_TO_INDEX, &scrollToIndexItem);
2781 
2782     nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &dividerItem);
2783     nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &dividerItem);
2784 
2785     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item2);
2786     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
2787     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_STICKY), ARKUI_ERROR_CODE_NO_ERROR);
2788     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_SPACE), ARKUI_ERROR_CODE_NO_ERROR);
2789     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
2790     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
2791     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM), ARKUI_ERROR_CODE_NO_ERROR);
2792     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_CHILDREN_MAIN_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
2793     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_INITIAL_INDEX), ARKUI_ERROR_CODE_NO_ERROR);
2794     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_DIVIDER), ARKUI_ERROR_CODE_NO_ERROR);
2795     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_FRICTION), ARKUI_ERROR_CODE_NO_ERROR);
2796     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), ARKUI_ERROR_CODE_NO_ERROR);
2797     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
2798     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2799     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), ARKUI_ERROR_CODE_NO_ERROR);
2800     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), ARKUI_ERROR_CODE_NO_ERROR);
2801     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR);
2802 
2803     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_DIRECTION), nullptr);
2804     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_STICKY), nullptr);
2805     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_SPACE), nullptr);
2806     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_NODE_ADAPTER), nullptr);
2807     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_CACHED_COUNT), nullptr);
2808     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM), nullptr);
2809     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_INITIAL_INDEX), nullptr);
2810     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_DIVIDER), nullptr);
2811     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION), nullptr);
2812     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), nullptr);
2813     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), nullptr);
2814     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_COLOR), nullptr);
2815     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), nullptr);
2816     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), nullptr);
2817     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), nullptr);
2818 
2819     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_LIST_ITEM_SWIPE_ACTION), ARKUI_ERROR_CODE_NO_ERROR);
2820 
2821     EXPECT_EQ(nodeAPI->resetAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_HEADER), ARKUI_ERROR_CODE_NO_ERROR);
2822     EXPECT_EQ(nodeAPI->resetAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_FOOTER), ARKUI_ERROR_CODE_NO_ERROR);
2823     EXPECT_EQ(nodeAPI->resetAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER), ARKUI_ERROR_CODE_NO_ERROR);
2824     EXPECT_EQ(nodeAPI->resetAttribute(groupNode, NODE_LIST_ITEM_GROUP_CHILDREN_MAIN_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
2825 
2826     EXPECT_NE(nodeAPI->getAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER), nullptr);
2827 
2828     nodeAPI->disposeNode(rootNode);
2829     nodeAPI->disposeNode(childNode);
2830     nodeAPI->disposeNode(groupNode);
2831 }
2832 
2833 /**
2834  * @tc.name: NativeNodeTest028
2835  * @tc.desc: Test swiperNode function.
2836  * @tc.type: FUNC
2837  */
2838 HWTEST_F(NativeNodeTest, NativeNodeTest028, TestSize.Level1)
2839 {
2840     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2841         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2842     auto rootNode = new ArkUI_Node({ARKUI_NODE_SWIPER, nullptr, true});
2843     ArkUI_NumberValue value[] = {{.i32 = ARKUI_CURVE_LINEAR}};
2844     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2845     ArkUI_NumberValue value2[] = {{.i32 = 1}, {.i32 = 1}};
2846     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2847     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2848     value[0].i32 = ARKUI_CURVE_EASE;
2849     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2850     value[0].i32 = ARKUI_CURVE_EASE_IN;
2851     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2852     value[0].i32 = ARKUI_CURVE_EASE_OUT;
2853     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2854     value[0].i32 = ARKUI_CURVE_EASE_IN_OUT;
2855     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2856     value[0].i32 = ARKUI_CURVE_FAST_OUT_SLOW_IN;
2857     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2858     value[0].i32 = ARKUI_CURVE_LINEAR_OUT_SLOW_IN;
2859     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2860     value[0].i32 = ARKUI_CURVE_FAST_OUT_LINEAR_IN;
2861     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2862     value[0].i32 = ARKUI_CURVE_EXTREME_DECELERATION;
2863     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2864     value[0].i32 = ARKUI_CURVE_SHARP;
2865     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2866     value[0].i32 = ARKUI_CURVE_RHYTHM;
2867     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2868     value[0].i32 = ARKUI_CURVE_SMOOTH;
2869     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2870     value[0].i32 = ARKUI_CURVE_FRICTION;
2871     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2872     value[0].i32 = ARKUI_SWIPER_ARROW_HIDE;
2873     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW, &item);
2874     value[0].i32 = ARKUI_SWIPER_ARROW_SHOW_ON_HOVER;
2875     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW, &item);
2876     value[0].i32 = ARKUI_EDGE_EFFECT_SPRING;
2877     nodeAPI->setAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE, &item);
2878     value[0].i32 = ARKUI_SWIPER_NESTED_SRCOLL_SELF_ONLY;
2879     nodeAPI->setAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL, &item);
2880     value[0].i32 = true;
2881     nodeAPI->setAttribute(rootNode, NODE_SWIPER_LOOP, &item);
2882     nodeAPI->setAttribute(rootNode, NODE_SWIPER_AUTO_PLAY, &item);
2883     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR, &item);
2884     nodeAPI->setAttribute(rootNode, NODE_SWIPER_VERTICAL, &item);
2885     nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDEX, &item);
2886     nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISPLAY_COUNT, &item);
2887     nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE, &item);
2888     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CACHED_COUNT, &item);
2889     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SWIPE_TO_INDEX, &item);
2890     nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR_INTERACTIVE, &item);
2891 
2892     value[0].f32 = 10.0f;
2893     nodeAPI->setAttribute(rootNode, NODE_SWIPER_INTERVAL, &item);
2894     nodeAPI->setAttribute(rootNode, NODE_SWIPER_DURATION, &item);
2895     nodeAPI->setAttribute(rootNode, NODE_SWIPER_ITEM_SPACE, &item);
2896     nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &item);
2897     nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &item);
2898 
2899     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SWIPE_TO_INDEX, &item2);
2900     value2[1].i32 = -1;
2901     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SWIPE_TO_INDEX, &item2);
2902 
2903     value2[0].f32 = 10.0f;
2904     value2[1].i32 = 1;
2905     nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &item);
2906     nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &item);
2907     value2[1].i32 = -1;
2908     nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &item);
2909     nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &item);
2910 
2911     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_LOOP), ARKUI_ERROR_CODE_NO_ERROR);
2912     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_AUTO_PLAY), ARKUI_ERROR_CODE_NO_ERROR);
2913     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR), ARKUI_ERROR_CODE_NO_ERROR);
2914     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_INTERVAL), ARKUI_ERROR_CODE_NO_ERROR);
2915     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_VERTICAL), ARKUI_ERROR_CODE_NO_ERROR);
2916     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_DURATION), ARKUI_ERROR_CODE_NO_ERROR);
2917     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_CURVE), ARKUI_ERROR_CODE_NO_ERROR);
2918     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_ITEM_SPACE), ARKUI_ERROR_CODE_NO_ERROR);
2919     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_INDEX), ARKUI_ERROR_CODE_NO_ERROR);
2920     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_DISPLAY_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
2921     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE), ARKUI_ERROR_CODE_NO_ERROR);
2922     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW), ARKUI_ERROR_CODE_NO_ERROR);
2923     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE), ARKUI_ERROR_CODE_NO_ERROR);
2924     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
2925     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
2926     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_PREV_MARGIN), ARKUI_ERROR_CODE_NO_ERROR);
2927     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN), ARKUI_ERROR_CODE_NO_ERROR);
2928     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_INDICATOR), ARKUI_ERROR_CODE_NO_ERROR);
2929     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR);
2930     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_INDICATOR_INTERACTIVE), ARKUI_ERROR_CODE_NO_ERROR);
2931 
2932     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_LOOP), nullptr);
2933     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_AUTO_PLAY), nullptr);
2934     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR), nullptr);
2935     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_INTERVAL), nullptr);
2936     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_VERTICAL), nullptr);
2937     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_DURATION), nullptr);
2938     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_CURVE), nullptr);
2939     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_ITEM_SPACE), nullptr);
2940     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_INDEX), nullptr);
2941     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_DISPLAY_COUNT), nullptr);
2942     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE), nullptr);
2943     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW), nullptr);
2944     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE), nullptr);
2945     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_NODE_ADAPTER), nullptr);
2946     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_CACHED_COUNT), nullptr);
2947     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_PREV_MARGIN), nullptr);
2948     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN), nullptr);
2949     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_INDICATOR), nullptr);
2950     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL), nullptr);
2951     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_INDICATOR_INTERACTIVE), nullptr);
2952     nodeAPI->disposeNode(rootNode);
2953 }
2954 
2955 /**
2956  * @tc.name: NativeNodeTest029
2957  * @tc.desc: Test columnNode function.
2958  * @tc.type: FUNC
2959  */
2960 HWTEST_F(NativeNodeTest, NativeNodeTest029, TestSize.Level1)
2961 {
2962     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2963         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2964     auto rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
2965     ASSERT_NE(rootNode, nullptr);
2966     ArkUI_NumberValue value[] = {{.i32 = ARKUI_HORIZONTAL_ALIGNMENT_CENTER}};
2967     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2968     nodeAPI->setAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS, &item);
2969     value[0].i32 = ARKUI_FLEX_ALIGNMENT_START;
2970     nodeAPI->setAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT, &item);
2971     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS), ARKUI_ERROR_CODE_NO_ERROR);
2972     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
2973 
2974     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS), nullptr);
2975     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT), nullptr);
2976     nodeAPI->disposeNode(rootNode);
2977 }
2978 
2979 /**
2980  * @tc.name: NativeNodeTest030
2981  * @tc.desc: Test rowNode function.
2982  * @tc.type: FUNC
2983  */
2984 HWTEST_F(NativeNodeTest, NativeNodeTest030, TestSize.Level1)
2985 {
2986     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2987         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2988     auto rootNode = nodeAPI->createNode(ARKUI_NODE_ROW);
2989     ASSERT_NE(rootNode, nullptr);
2990     ArkUI_NumberValue value[] = {{.i32 = ARKUI_VERTICAL_ALIGNMENT_CENTER}};
2991     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2992     nodeAPI->setAttribute(rootNode, NODE_ROW_ALIGN_ITEMS, &item);
2993     value[0].i32 = ARKUI_FLEX_ALIGNMENT_START;
2994     nodeAPI->setAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT, &item);
2995     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ROW_ALIGN_ITEMS), ARKUI_ERROR_CODE_NO_ERROR);
2996     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
2997 
2998     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_ROW_ALIGN_ITEMS), nullptr);
2999     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT), nullptr);
3000     nodeAPI->disposeNode(rootNode);
3001 }
3002 
3003 /**
3004  * @tc.name: NativeNodeTest031
3005  * @tc.desc: Test flexNode function.
3006  * @tc.type: FUNC
3007  */
3008 HWTEST_F(NativeNodeTest, NativeNodeTest031, TestSize.Level1)
3009 {
3010     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3011         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3012     auto rootNode = nodeAPI->createNode(ARKUI_NODE_FLEX);
3013     auto childNode = nodeAPI->createNode(ARKUI_NODE_STACK);
3014     ASSERT_NE(rootNode, nullptr);
3015     ASSERT_NE(childNode, nullptr);
3016     nodeAPI->addChild(rootNode, childNode);
3017 
3018     ArkUI_NumberValue value0[] = {};
3019     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3020     int32_t negativeEnum = -1;
3021     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeEnum}};
3022     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
3023     float negativeFloat = -1.0f;
3024     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}};
3025     ArkUI_AttributeItem itemFloat = {valueFloat, sizeof(valueFloat) / sizeof(ArkUI_NumberValue)};
3026     ArkUI_NumberValue value[] = {{.i32 = ARKUI_ITEM_ALIGNMENT_AUTO}};
3027     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3028     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_ALIGN_SELF, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3029     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_ALIGN_SELF, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3030     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_ALIGN_SELF, &item), ARKUI_ERROR_CODE_NO_ERROR);
3031     auto alignSelfVal = nodeAPI->getAttribute(childNode, NODE_ALIGN_SELF);
3032     EXPECT_EQ(alignSelfVal->value[0].i32, static_cast<int32_t>(ARKUI_ITEM_ALIGNMENT_AUTO));
3033 
3034     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_GROW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3035     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_GROW, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
3036     float flexGrowInput = 2.0f;
3037     value[0].f32 = flexGrowInput;
3038     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_GROW, &item), ARKUI_ERROR_CODE_NO_ERROR);
3039     auto flexGrowVal = nodeAPI->getAttribute(childNode, NODE_FLEX_GROW);
3040     EXPECT_EQ(flexGrowVal->value[0].f32, flexGrowInput);
3041 
3042     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_SHRINK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3043     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_SHRINK, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
3044     float flexShrinkInput = 0.0f;
3045     value[0].f32 = flexShrinkInput;
3046     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_SHRINK, &item), ARKUI_ERROR_CODE_NO_ERROR);
3047     auto flexShrinkVal = nodeAPI->getAttribute(childNode, NODE_FLEX_SHRINK);
3048     EXPECT_EQ(flexShrinkVal->value[0].f32, flexShrinkInput);
3049 
3050     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_BASIS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3051     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_BASIS, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
3052     float flexBasisInput = 100.0f;
3053     value[0].f32 = flexBasisInput;
3054     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_BASIS, &item), ARKUI_ERROR_CODE_NO_ERROR);
3055     auto flexBasisVal = nodeAPI->getAttribute(childNode, NODE_FLEX_BASIS);
3056     EXPECT_EQ(flexBasisVal->value[0].f32, flexBasisInput);
3057 
3058     ArkUI_NumberValue flexOptVal[] = {{.i32 = ARKUI_FLEX_DIRECTION_ROW}, {.i32 = ARKUI_FLEX_WRAP_NO_WRAP},
3059         {.i32 = ARKUI_FLEX_ALIGNMENT_START}, {.i32 = ARKUI_ITEM_ALIGNMENT_START}, {.i32 = ARKUI_FLEX_ALIGNMENT_START}};
3060     ArkUI_AttributeItem flexOptItem = {flexOptVal, sizeof(flexOptVal) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3061     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_NO_ERROR);
3062     auto flexOptResult = nodeAPI->getAttribute(rootNode, NODE_FLEX_OPTION);
3063     EXPECT_EQ(flexOptResult->value[0].i32, static_cast<int32_t>(ARKUI_FLEX_DIRECTION_ROW));
3064 
3065     int32_t abnormalVal = 10;
3066     flexOptVal[4].i32 = abnormalVal;
3067     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3068     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3069     flexOptVal[3].i32 = abnormalVal;
3070     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3071     flexOptVal[2].i32 = abnormalVal;
3072     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3073     flexOptVal[1].i32 = abnormalVal;
3074     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3075     flexOptVal[0].i32 = abnormalVal;
3076     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3077     flexOptItem.size = -1;
3078     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_NO_ERROR);
3079 
3080     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_ALIGN_SELF), ARKUI_ERROR_CODE_NO_ERROR);
3081     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_FLEX_GROW), ARKUI_ERROR_CODE_NO_ERROR);
3082     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_FLEX_SHRINK), ARKUI_ERROR_CODE_NO_ERROR);
3083     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_FLEX_BASIS), ARKUI_ERROR_CODE_NO_ERROR);
3084     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FLEX_OPTION), ARKUI_ERROR_CODE_NO_ERROR);
3085     nodeAPI->disposeNode(childNode);
3086     nodeAPI->disposeNode(rootNode);
3087 }
3088 
3089 /**
3090  * @tc.name: NativeNodeTest032
3091  * @tc.desc: Test refreshNode function.
3092  * @tc.type: FUNC
3093  */
3094 HWTEST_F(NativeNodeTest, NativeNodeTest032, TestSize.Level1)
3095 {
3096     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3097         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3098     auto rootNode = new ArkUI_Node({ARKUI_NODE_REFRESH, nullptr, true});
3099     ASSERT_NE(rootNode, nullptr);
3100     ArkUI_NumberValue value[] = {{.i32 = true}};
3101     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3102     nodeAPI->setAttribute(rootNode, NODE_REFRESH_REFRESHING, &item);
3103     nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &item);
3104     value[0].f32 = 0.5f;
3105     nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &item);
3106     nodeAPI->setAttribute(rootNode, NODE_REFRESH_OFFSET, &item);
3107     item.object = rootNode;
3108     nodeAPI->setAttribute(rootNode, NODE_REFRESH_CONTENT, &item);
3109     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_REFRESH_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
3110     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO), ARKUI_ERROR_CODE_NO_ERROR);
3111     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_REFRESH_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
3112     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_REFRESH_PULL_TO_REFRESH), ARKUI_ERROR_CODE_NO_ERROR);
3113 
3114     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_REFRESH_REFRESHING), nullptr);
3115     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_REFRESH_CONTENT), nullptr);
3116     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO), nullptr);
3117     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_REFRESH_OFFSET), nullptr);
3118     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_REFRESH_PULL_TO_REFRESH), nullptr);
3119     nodeAPI->disposeNode(rootNode);
3120 }
3121 
3122 /**
3123  * @tc.name: NativeNodeTest033
3124  * @tc.desc: Test waterflowNode function.
3125  * @tc.type: FUNC
3126  */
3127 HWTEST_F(NativeNodeTest, NativeNodeTest033, TestSize.Level1)
3128 {
3129     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3130         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3131     auto rootNode = new ArkUI_Node({ARKUI_NODE_WATER_FLOW, nullptr, true});
3132     float distance = 10.0f;
3133     uint32_t color = 0xFFFF0000;
3134     ArkUI_NumberValue value[] = {{.f32 = distance}};
3135     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3136     ArkUI_NumberValue value2[] = {{.f32 = distance}, {.f32 = distance}};
3137     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
3138     ArkUI_NumberValue scrollnested[] = {{.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY},
3139         {.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY}};
3140     ArkUI_AttributeItem scrollnestedItem = {scrollnested, sizeof(scrollnested) / sizeof(ArkUI_NumberValue)};
3141     ArkUI_NumberValue constraintSize[] = {{.f32 = distance}, {.f32 = distance}, {.f32 = distance}, {.f32 = distance}};
3142     ArkUI_AttributeItem constraintSizeItem = {constraintSize, sizeof(constraintSize) / sizeof(ArkUI_NumberValue)};
3143     ArkUI_NumberValue indexValue[] = {{.i32 = 0}, {.i32 = 0}, {.i32 = ARKUI_SCROLL_ALIGNMENT_START}};
3144     ArkUI_AttributeItem indexItem = {indexValue, sizeof(indexValue) / sizeof(ArkUI_NumberValue)};
3145     nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item);
3146     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item);
3147     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP, &item);
3148     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP, &item);
3149     value[0].u32 = color;
3150     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item);
3151 
3152     value[0].i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO;
3153     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item);
3154     value[0].i32 = ARKUI_EDGE_EFFECT_NONE;
3155     nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item);
3156     value[0].i32 = ARKUI_FLEX_DIRECTION_ROW;
3157     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION, &item);
3158     value[0].i32 = true;
3159     nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item);
3160     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT, &item);
3161     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &item);
3162 
3163     item.string = "test";
3164     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_TEMPLATE, &item);
3165     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_TEMPLATE, &item);
3166 
3167     item.object = rootNode;
3168     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_FOOTER, &item);
3169 
3170     nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &scrollnestedItem);
3171     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item2);
3172     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE, &constraintSizeItem);
3173     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &indexItem);
3174     indexValue[2].i32 = ARKUI_SCROLL_ALIGNMENT_NONE;
3175     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &indexItem);
3176     indexValue[2].i32 = -1;
3177     indexValue[1].i32 = -1;
3178     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &indexItem);
3179     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
3180     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_COLUMN_TEMPLATE), ARKUI_ERROR_CODE_NO_ERROR);
3181     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_ROW_TEMPLATE), ARKUI_ERROR_CODE_NO_ERROR);
3182     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP), ARKUI_ERROR_CODE_NO_ERROR);
3183     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP), ARKUI_ERROR_CODE_NO_ERROR);
3184     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION), ARKUI_ERROR_CODE_NO_ERROR);
3185     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
3186     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
3187     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_FOOTER), ARKUI_ERROR_CODE_NO_ERROR);
3188     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
3189     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_FRICTION), ARKUI_ERROR_CODE_NO_ERROR);
3190     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), ARKUI_ERROR_CODE_NO_ERROR);
3191     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
3192     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
3193     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), ARKUI_ERROR_CODE_NO_ERROR);
3194     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), ARKUI_ERROR_CODE_NO_ERROR);
3195     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR);
3196 
3197     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION), nullptr);
3198     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_COLUMN_TEMPLATE), nullptr);
3199     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_ROW_TEMPLATE), nullptr);
3200     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP), nullptr);
3201     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP), nullptr);
3202     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_NODE_ADAPTER), nullptr);
3203     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT), nullptr);
3204     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE), nullptr);
3205     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION), nullptr);
3206     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), nullptr);
3207     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), nullptr);
3208     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_COLOR), nullptr);
3209     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), nullptr);
3210     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), nullptr);
3211     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), nullptr);
3212     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION), nullptr);
3213     nodeAPI->disposeNode(rootNode);
3214 }
3215 
3216 /**
3217  * @tc.name: NativeNodeTest034
3218  * @tc.desc: Test gridNode function.
3219  * @tc.type: FUNC
3220  */
3221 HWTEST_F(NativeNodeTest, NativeNodeTest034, TestSize.Level1)
3222 {
3223     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3224         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3225     auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID);
3226     ASSERT_NE(rootNode, nullptr);
3227     ArkUI_NumberValue value[] = {{.f32 = 1.0f}};
3228     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"};
3229     nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_TEMPLATE, &item);
3230     nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_TEMPLATE, &item);
3231     nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_GAP, &item);
3232     nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_GAP, &item);
3233     value[0].i32 = 1;
3234     nodeAPI->setAttribute(rootNode, NODE_GRID_CACHED_COUNT, &item);
3235     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_COLUMN_TEMPLATE), ARKUI_ERROR_CODE_NO_ERROR);
3236     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_ROW_TEMPLATE), ARKUI_ERROR_CODE_NO_ERROR);
3237     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_COLUMN_GAP), ARKUI_ERROR_CODE_NO_ERROR);
3238     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_ROW_GAP), ARKUI_ERROR_CODE_NO_ERROR);
3239     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
3240     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
3241 
3242     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_COLUMN_TEMPLATE), nullptr);
3243     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_ROW_TEMPLATE), nullptr);
3244     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_COLUMN_GAP), nullptr);
3245     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_ROW_GAP), nullptr);
3246     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_NODE_ADAPTER), nullptr);
3247     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_CACHED_COUNT), nullptr);
3248     nodeAPI->disposeNode(rootNode);
3249 }
3250 
3251 /**
3252  * @tc.name: NativeNodeTest035
3253  * @tc.desc: Test relativeContainerNode function.
3254  * @tc.type: FUNC
3255  */
3256 HWTEST_F(NativeNodeTest, NativeNodeTest035, TestSize.Level1)
3257 {
3258     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3259         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3260     auto rootNode = new ArkUI_Node({ARKUI_NODE_RELATIVE_CONTAINER, nullptr, true});
3261     ASSERT_NE(rootNode, nullptr);
3262 
3263     auto alignRules = OH_ArkUI_AlignmentRuleOption_Create();
3264     float baisVal = 10.0f;
3265     ArkUI_AttributeItem alignRulesItem = {.size = 0, .object = alignRules};
3266     nodeAPI->setAttribute(rootNode, NODE_ALIGN_RULES, &alignRulesItem);
3267     OH_ArkUI_AlignmentRuleOption_SetStart(nullptr, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_START);
3268     OH_ArkUI_AlignmentRuleOption_SetStart(alignRules, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_START);
3269     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetStartId(alignRules), nullptr);
3270     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetStartAlignment(alignRules), static_cast<ArkUI_HorizontalAlignment>(-1));
3271     OH_ArkUI_AlignmentRuleOption_SetStart(alignRules, "__container__", ARKUI_HORIZONTAL_ALIGNMENT_START);
3272     OH_ArkUI_AlignmentRuleOption_SetTop(nullptr, nullptr, ARKUI_VERTICAL_ALIGNMENT_TOP);
3273     OH_ArkUI_AlignmentRuleOption_SetTop(alignRules, nullptr, ARKUI_VERTICAL_ALIGNMENT_TOP);
3274     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetTopId(alignRules), nullptr);
3275     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetTopAlignment(alignRules), static_cast<ArkUI_VerticalAlignment>(-1));
3276     OH_ArkUI_AlignmentRuleOption_SetTop(alignRules, "__container__", ARKUI_VERTICAL_ALIGNMENT_TOP);
3277     OH_ArkUI_AlignmentRuleOption_SetEnd(nullptr, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_END);
3278     OH_ArkUI_AlignmentRuleOption_SetEnd(alignRules, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_END);
3279     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetEndId(alignRules), nullptr);
3280     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetEndAlignment(alignRules), static_cast<ArkUI_HorizontalAlignment>(-1));
3281     OH_ArkUI_AlignmentRuleOption_SetEnd(alignRules, "__container__", ARKUI_HORIZONTAL_ALIGNMENT_END);
3282     OH_ArkUI_AlignmentRuleOption_SetBottom(nullptr, nullptr, ARKUI_VERTICAL_ALIGNMENT_BOTTOM);
3283     OH_ArkUI_AlignmentRuleOption_SetBottom(alignRules, nullptr, ARKUI_VERTICAL_ALIGNMENT_BOTTOM);
3284     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBottomId(alignRules), nullptr);
3285     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBottomAlignment(alignRules), static_cast<ArkUI_VerticalAlignment>(-1));
3286     OH_ArkUI_AlignmentRuleOption_SetBottom(alignRules, "__container__", ARKUI_VERTICAL_ALIGNMENT_BOTTOM);
3287     OH_ArkUI_AlignmentRuleOption_SetCenterHorizontal(nullptr, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_CENTER);
3288     OH_ArkUI_AlignmentRuleOption_SetCenterHorizontal(alignRules, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_CENTER);
3289     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterIdHorizontal(alignRules), nullptr);
3290     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentHorizontal(alignRules),
3291         static_cast<ArkUI_HorizontalAlignment>(-1));
3292     OH_ArkUI_AlignmentRuleOption_SetCenterHorizontal(alignRules, "__container__", ARKUI_HORIZONTAL_ALIGNMENT_CENTER);
3293     OH_ArkUI_AlignmentRuleOption_SetCenterVertical(nullptr, nullptr, ARKUI_VERTICAL_ALIGNMENT_CENTER);
3294     OH_ArkUI_AlignmentRuleOption_SetCenterVertical(alignRules, nullptr, ARKUI_VERTICAL_ALIGNMENT_CENTER);
3295     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterIdVertical(alignRules), nullptr);
3296     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentVertical(alignRules),
3297         static_cast<ArkUI_VerticalAlignment>(-1));
3298     OH_ArkUI_AlignmentRuleOption_SetCenterVertical(alignRules, "__container__", ARKUI_VERTICAL_ALIGNMENT_CENTER);
3299     OH_ArkUI_AlignmentRuleOption_SetBiasHorizontal(nullptr, baisVal);
3300     OH_ArkUI_AlignmentRuleOption_SetBiasHorizontal(alignRules, baisVal);
3301     OH_ArkUI_AlignmentRuleOption_SetBiasVertical(nullptr, baisVal);
3302     OH_ArkUI_AlignmentRuleOption_SetBiasVertical(alignRules, baisVal);
3303     alignRulesItem.object = alignRules;
3304     nodeAPI->setAttribute(rootNode, NODE_ALIGN_RULES, &alignRulesItem);
3305     auto alignRulesGetVal = nodeAPI->getAttribute(rootNode, NODE_ALIGN_RULES);
3306     ASSERT_NE(alignRulesGetVal, nullptr);
3307     OH_ArkUI_AlignmentRuleOption_GetStartId(alignRules);
3308     OH_ArkUI_AlignmentRuleOption_GetStartAlignment(alignRules);
3309     OH_ArkUI_AlignmentRuleOption_GetEndId(alignRules);
3310     OH_ArkUI_AlignmentRuleOption_GetEndAlignment(alignRules);
3311     OH_ArkUI_AlignmentRuleOption_GetCenterIdHorizontal(alignRules);
3312     OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentHorizontal(alignRules);
3313     OH_ArkUI_AlignmentRuleOption_GetTopId(alignRules);
3314     OH_ArkUI_AlignmentRuleOption_GetTopAlignment(alignRules);
3315     OH_ArkUI_AlignmentRuleOption_GetBottomId(alignRules);
3316     OH_ArkUI_AlignmentRuleOption_GetBottomAlignment(alignRules);
3317     OH_ArkUI_AlignmentRuleOption_GetCenterIdVertical(alignRules);
3318     OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentVertical(alignRules);
3319     OH_ArkUI_AlignmentRuleOption_GetBiasHorizontal(alignRules);
3320     OH_ArkUI_AlignmentRuleOption_GetBiasVertical(alignRules);
3321 
3322     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetStartId(nullptr), nullptr);
3323     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetStartAlignment(nullptr), static_cast<ArkUI_HorizontalAlignment>(-1));
3324     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetEndId(nullptr), nullptr);
3325     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetEndAlignment(nullptr), static_cast<ArkUI_HorizontalAlignment>(-1));
3326     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterIdHorizontal(nullptr), nullptr);
3327     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentHorizontal(nullptr),
3328         static_cast<ArkUI_HorizontalAlignment>(-1));
3329     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetTopId(nullptr), nullptr);
3330     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetTopAlignment(nullptr), static_cast<ArkUI_VerticalAlignment>(-1));
3331     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBottomId(nullptr), nullptr);
3332     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBottomAlignment(nullptr), static_cast<ArkUI_VerticalAlignment>(-1));
3333     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterIdVertical(nullptr), nullptr);
3334     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentVertical(nullptr),
3335         static_cast<ArkUI_VerticalAlignment>(-1));
3336     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBiasHorizontal(nullptr), -1.0f);
3337     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBiasVertical(nullptr), -1.0f);
3338 
3339 
3340     ArkUI_NumberValue chainModeVal[] = {{.i32 = ARKUI_AXIS_HORIZONTAL},
3341         {.i32 = ARKUI_RELATIVE_LAYOUT_CHAIN_STYLE_PACKED}};
3342     ArkUI_AttributeItem chainModeItem = {chainModeVal, sizeof(chainModeVal) / sizeof(ArkUI_NumberValue)};
3343     auto chainModRet = nodeAPI->setAttribute(rootNode, NODE_RELATIVE_LAYOUT_CHAIN_MODE, &chainModeItem);
3344     EXPECT_EQ(chainModRet, ARKUI_ERROR_CODE_NO_ERROR);
3345     EXPECT_EQ(nodeAPI->setAttribute(
3346         rootNode, NODE_RELATIVE_LAYOUT_CHAIN_MODE, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3347     auto chainModResult = nodeAPI->getAttribute(rootNode, NODE_RELATIVE_LAYOUT_CHAIN_MODE);
3348     EXPECT_NE(chainModResult, nullptr);
3349 
3350     int32_t guideLineOptSize = 1;
3351     float positionStart = 50.0f;
3352     float positionEnd = 60.0f;
3353     auto guidelineOption = OH_ArkUI_GuidelineOption_Create(guideLineOptSize);
3354     OH_ArkUI_GuidelineOption_SetId(nullptr, nullptr, 0);
3355     OH_ArkUI_GuidelineOption_SetId(guidelineOption, nullptr, -1);
3356     OH_ArkUI_GuidelineOption_SetId(guidelineOption, nullptr, 2);
3357     OH_ArkUI_GuidelineOption_SetId(guidelineOption, "__container__", 0);
3358     OH_ArkUI_GuidelineOption_SetDirection(nullptr, ARKUI_AXIS_VERTICAL, 0);
3359     OH_ArkUI_GuidelineOption_SetDirection(guidelineOption, ARKUI_AXIS_VERTICAL, -1);
3360     OH_ArkUI_GuidelineOption_SetDirection(guidelineOption, ARKUI_AXIS_VERTICAL, 2);
3361     OH_ArkUI_GuidelineOption_SetDirection(guidelineOption, ARKUI_AXIS_VERTICAL, 0);
3362     OH_ArkUI_GuidelineOption_SetPositionStart(nullptr, positionStart, 0);
3363     OH_ArkUI_GuidelineOption_SetPositionStart(guidelineOption, positionStart, -1);
3364     OH_ArkUI_GuidelineOption_SetPositionStart(guidelineOption, positionStart, 2);
3365     OH_ArkUI_GuidelineOption_SetPositionStart(guidelineOption, positionStart, 0);
3366     OH_ArkUI_GuidelineOption_SetPositionEnd(nullptr, positionEnd, 0);
3367     OH_ArkUI_GuidelineOption_SetPositionEnd(guidelineOption, positionEnd, -1);
3368     OH_ArkUI_GuidelineOption_SetPositionEnd(guidelineOption, positionEnd, 2);
3369     OH_ArkUI_GuidelineOption_SetPositionEnd(guidelineOption, positionEnd, 0);
3370     ArkUI_AttributeItem guidelineOptItem = {.object = guidelineOption};
3371     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RELATIVE_CONTAINER_GUIDE_LINE, &guidelineOptItem),
3372         ARKUI_ERROR_CODE_NO_ERROR);
3373     auto guidelineOptResult = nodeAPI->getAttribute(rootNode, NODE_RELATIVE_CONTAINER_GUIDE_LINE);
3374     ASSERT_NE(guidelineOptResult, nullptr);
3375     OH_ArkUI_GuidelineOption_GetId(guidelineOption, 0);
3376     OH_ArkUI_GuidelineOption_GetDirection(guidelineOption, 0);
3377     OH_ArkUI_GuidelineOption_GetPositionStart(guidelineOption, 0);
3378     OH_ArkUI_GuidelineOption_GetPositionEnd(guidelineOption, 0);
3379     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetId(nullptr, 0), nullptr);
3380     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetId(guidelineOption, -1), nullptr);
3381     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetId(guidelineOption, 2), nullptr);
3382     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetDirection(nullptr, 0), static_cast<ArkUI_Axis>(-1));
3383     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetDirection(guidelineOption, -1), static_cast<ArkUI_Axis>(-1));
3384     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetDirection(guidelineOption, 2), static_cast<ArkUI_Axis>(-1));
3385     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionStart(nullptr, 0), 0.0f);
3386     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionStart(guidelineOption, -1), 0.0f);
3387     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionStart(guidelineOption, 2), 0.0f);
3388     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionEnd(nullptr, 0), 0.0f);
3389     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionEnd(guidelineOption, -1), 0.0f);
3390     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionEnd(guidelineOption, 2), 0.0f);
3391 
3392     auto abnormalBarrierOption = OH_ArkUI_BarrierOption_Create(-1);
3393     auto barrierOption = OH_ArkUI_BarrierOption_Create(guideLineOptSize);
3394     OH_ArkUI_BarrierOption_SetId(nullptr, nullptr, 0);
3395     OH_ArkUI_BarrierOption_SetId(barrierOption, nullptr, -1);
3396     OH_ArkUI_BarrierOption_SetId(barrierOption, nullptr, 2);
3397     OH_ArkUI_BarrierOption_SetId(barrierOption, "__container__", 0);
3398     OH_ArkUI_BarrierOption_SetDirection(nullptr, ARKUI_BARRIER_DIRECTION_TOP, 0);
3399     OH_ArkUI_BarrierOption_SetDirection(barrierOption, ARKUI_BARRIER_DIRECTION_TOP, -1);
3400     OH_ArkUI_BarrierOption_SetDirection(barrierOption, ARKUI_BARRIER_DIRECTION_TOP, 2);
3401     OH_ArkUI_BarrierOption_SetDirection(barrierOption, ARKUI_BARRIER_DIRECTION_TOP, 0);
3402     OH_ArkUI_BarrierOption_SetReferencedId(nullptr, nullptr, 0);
3403     OH_ArkUI_BarrierOption_SetReferencedId(barrierOption, nullptr, -1);
3404     OH_ArkUI_BarrierOption_SetReferencedId(barrierOption, nullptr, 2);
3405     OH_ArkUI_BarrierOption_SetReferencedId(barrierOption, "__container__", 0);
3406     ArkUI_AttributeItem barrierOptItem = {.object = barrierOption};
3407     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RELATIVE_CONTAINER_BARRIER, &barrierOptItem),
3408         ARKUI_ERROR_CODE_NO_ERROR);
3409     auto barrierOptResult = nodeAPI->getAttribute(rootNode, NODE_RELATIVE_CONTAINER_BARRIER);
3410     ASSERT_NE(barrierOptResult, nullptr);
3411     OH_ArkUI_BarrierOption_GetId(barrierOption, 0);
3412     OH_ArkUI_BarrierOption_GetDirection(barrierOption, 0);
3413     OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, 0, 0);
3414     OH_ArkUI_BarrierOption_GetReferencedIdSize(barrierOption, 0);
3415     EXPECT_EQ(OH_ArkUI_BarrierOption_GetId(nullptr, 0), nullptr);
3416     EXPECT_EQ(OH_ArkUI_BarrierOption_GetId(barrierOption, -1), nullptr);
3417     EXPECT_EQ(OH_ArkUI_BarrierOption_GetId(barrierOption, 2), nullptr);
3418     EXPECT_EQ(OH_ArkUI_BarrierOption_GetDirection(nullptr, 0), ARKUI_BARRIER_DIRECTION_TOP);
3419     EXPECT_EQ(OH_ArkUI_BarrierOption_GetDirection(barrierOption, -1), ARKUI_BARRIER_DIRECTION_TOP);
3420     EXPECT_EQ(OH_ArkUI_BarrierOption_GetDirection(barrierOption, 2), ARKUI_BARRIER_DIRECTION_TOP);
3421     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(nullptr, 0, 0), nullptr);
3422     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, -1, 0), nullptr);
3423     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, 2, 0), nullptr);
3424     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, 0, -1), nullptr);
3425     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, 0, 2), nullptr);
3426     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedIdSize(nullptr, 0), 0);
3427     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedIdSize(barrierOption, -1), 0);
3428     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedIdSize(barrierOption, 2), 0);
3429 
3430     OH_ArkUI_AlignmentRuleOption_Dispose(alignRules);
3431     OH_ArkUI_GuidelineOption_Dispose(guidelineOption);
3432     OH_ArkUI_BarrierOption_Dispose(barrierOption);
3433     OH_ArkUI_BarrierOption_Dispose(abnormalBarrierOption);
3434 
3435     OH_ArkUI_AlignmentRuleOption_Dispose(nullptr);
3436     OH_ArkUI_GuidelineOption_Dispose(nullptr);
3437     OH_ArkUI_BarrierOption_Dispose(nullptr);
3438 
3439     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ALIGN_RULES), ARKUI_ERROR_CODE_NO_ERROR);
3440     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RELATIVE_LAYOUT_CHAIN_MODE), ARKUI_ERROR_CODE_NO_ERROR);
3441     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RELATIVE_CONTAINER_GUIDE_LINE), ARKUI_ERROR_CODE_NO_ERROR);
3442     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RELATIVE_CONTAINER_BARRIER), ARKUI_ERROR_CODE_NO_ERROR);
3443     nodeAPI->disposeNode(rootNode);
3444 }
3445 
3446 /**
3447  * @tc.name: NativeNodeTest036
3448  * @tc.desc: Test imageAnimatorNode function.
3449  * @tc.type: FUNC
3450  */
3451 HWTEST_F(NativeNodeTest, NativeNodeTest036, TestSize.Level1)
3452 {
3453     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3454         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3455     auto rootNode = new ArkUI_Node({ARKUI_NODE_IMAGE_ANIMATOR, nullptr, true});
3456     ASSERT_NE(rootNode, nullptr);
3457     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_IMAGES), ARKUI_ERROR_CODE_NO_ERROR);
3458     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE), ARKUI_ERROR_CODE_NO_ERROR);
3459     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_DURATION), ARKUI_ERROR_CODE_NO_ERROR);
3460     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE), ARKUI_ERROR_CODE_NO_ERROR);
3461     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
3462     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE), ARKUI_ERROR_CODE_NO_ERROR);
3463     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_ITERATION), ARKUI_ERROR_CODE_NO_ERROR);
3464 
3465     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_IMAGES), nullptr);
3466     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE), nullptr);
3467     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_DURATION), nullptr);
3468     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE), nullptr);
3469     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE), nullptr);
3470     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE), nullptr);
3471     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_ITERATION), nullptr);
3472     nodeAPI->disposeNode(rootNode);
3473 }
3474 
3475 /**
3476  * @tc.name: NativeNodeTest037
3477  * @tc.desc: Test abnormalInputForCommon function.
3478  * @tc.type: FUNC
3479  */
3480 HWTEST_F(NativeNodeTest, NativeNodeTest037, TestSize.Level1)
3481 {
3482     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3483         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3484     auto rootNode = new ArkUI_Node({ARKUI_NODE_STACK, nullptr, true});
3485     float negativeFloat = -1.0f;
3486     int32_t negativeEnum = -1;
3487     uint32_t color = 0XFFFF0000;
3488     float val0 = 0.0f;
3489     float val1 = 1.0f;
3490     float val10 = 10.0f;
3491     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3492     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3493     ArkUI_NumberValue value4[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
3494         {.f32 = negativeFloat}};
3495     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue)};
3496     ArkUI_NumberValue value0[] = {};
3497     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3498     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeEnum}};
3499     ArkUI_AttributeItem itemEnum = {valueEnum, 1, "test", nullptr};
3500     ArkUI_NumberValue valueEnum4[] = {{.i32 = negativeEnum}, {.i32 = negativeEnum}, {.i32 = negativeEnum},
3501         {.i32 = negativeEnum}};
3502     ArkUI_AttributeItem itemEnum4 = {valueEnum4, sizeof(valueEnum4) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3503 
3504     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3505     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3506     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HEIGHT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3507     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HEIGHT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3508     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH_PERCENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3509     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3510     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HEIGHT_PERCENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3511     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HEIGHT_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3512     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3513     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3514     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3515     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PADDING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3516     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PADDING_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3517     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ID, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3518     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ENABLED, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3519     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ENABLED, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3520     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARGIN, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3521     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARGIN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3522     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARGIN_PERCENT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3523     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARGIN_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3524     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3525     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3526     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSLATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3527     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCALE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3528     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROTATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3529     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BRIGHTNESS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3530     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BRIGHTNESS, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3531     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SATURATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3532     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SATURATION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3533     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BLUR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3534     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LINEAR_GRADIENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3535     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LINEAR_GRADIENT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3536     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGNMENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3537     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGNMENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3538     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3539     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3540     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3541     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3542     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3543     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3544     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3545     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3546     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3547     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3548     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3549     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3550     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3551     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3552     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3553     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3554     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3555     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3556     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_Z_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3557     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBILITY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3558     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBILITY, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3559     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3560     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3561     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3562     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3563     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSFORM, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3564     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3565     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3566     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_POSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3567     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SHADOW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3568     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SHADOW, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3569     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3570     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3571     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUSABLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3572     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUSABLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3573     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_GROUP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3574     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_GROUP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3575     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_TEXT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3576     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3577     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3578     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_DESCRIPTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3579     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ACTIONS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3580     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ROLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3581     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DEFAULT_FOCUS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3582     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DEFAULT_FOCUS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3583     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RESPONSE_REGION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3584     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3585     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3586     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_POSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3587     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3588     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3589     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIAL_GRADIENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3590     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIAL_GRADIENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3591     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3592     ArkUI_NumberValue mask[] = {{.u32 = color}, {.u32 = color}, {.f32 = val10}, {.i32 = ARKUI_MASK_TYPE_RECTANGLE},
3593         {.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
3594     ArkUI_AttributeItem maskItem = {mask, sizeof(mask) / sizeof(ArkUI_NumberValue)};
3595     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3596     maskItem.size = 5;
3597     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3598     mask[3].i32 = ARKUI_MASK_TYPE_PATH;
3599     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3600     mask[0].i32 = ARKUI_MASK_TYPE_PROGRESS;
3601     mask[1].f32 = negativeFloat;
3602     mask[3].u32 = color;
3603     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3604     mask[1].f32 = val10;
3605     mask[2].f32 = negativeFloat;
3606     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3607     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BLEND_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3608     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BLEND_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3609 
3610     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DIRECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3611     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DIRECTION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3612     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONSTRAINT_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3613     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONSTRAINT_SIZE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3614     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONSTRAINT_SIZE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3615     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRAY_SCALE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3616     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRAY_SCALE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3617     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_INVERT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3618     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_INVERT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3619     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SEPIA, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3620     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SEPIA, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3621     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONTRAST, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3622     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONTRAST, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3623     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3624     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3625     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARK_ANCHOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3626     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGN_RULES, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3627     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_STATUS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3628     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_STATUS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3629     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ASPECT_RATIO, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3630     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ASPECT_RATIO, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3631     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LAYOUT_WEIGHT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3632     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DISPLAY_PRIORITY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3633     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OUTLINE_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3634     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GEOMETRY_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3635     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_FIT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3636     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_FIT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3637     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OUTLINE_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3638     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3639     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SIZE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3640     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_GROUP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3641     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_GROUP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3642     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLOR_BLEND, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3643     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3644     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3645     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE, &item0),
3646         ARKUI_ERROR_CODE_PARAM_INVALID);
3647     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE, &itemEnum),
3648         ARKUI_ERROR_CODE_PARAM_INVALID);
3649     ArkUI_NumberValue backgroundBlurVal[] = {{.i32 = ARKUI_BLUR_STYLE_THIN}, {.i32 = ARKUI_COLOR_MODE_SYSTEM},
3650         {.i32 = ARKUI_ADAPTIVE_COLOR_DEFAULT}, {.f32 = 0}, {.f32 = 0}, {.f32 = negativeFloat}};
3651     ArkUI_AttributeItem backgroundBlurItem = {backgroundBlurVal, sizeof(backgroundBlurVal) / sizeof(ArkUI_NumberValue)};
3652     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3653     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_BLUR_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3654     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3655         ARKUI_ERROR_CODE_PARAM_INVALID);
3656     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_BLUR_STYLE, &backgroundBlurItem),
3657         ARKUI_ERROR_CODE_PARAM_INVALID);
3658     backgroundBlurVal[4].f32 = negativeFloat;
3659     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3660         ARKUI_ERROR_CODE_PARAM_INVALID);
3661     backgroundBlurVal[3].f32 = negativeFloat;
3662     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3663         ARKUI_ERROR_CODE_PARAM_INVALID);
3664     backgroundBlurVal[2].i32 = negativeEnum;
3665     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3666         ARKUI_ERROR_CODE_PARAM_INVALID);
3667     backgroundBlurVal[1].i32 = negativeEnum;
3668     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3669         ARKUI_ERROR_CODE_PARAM_INVALID);
3670     backgroundBlurVal[0].i32 = negativeEnum;
3671     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3672         ARKUI_ERROR_CODE_PARAM_INVALID);
3673     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3674     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3675     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROTATE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3676     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCALE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3677     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSLATE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3678     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MOVE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3679     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LAYOUT_RECT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3680     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LAYOUT_RECT, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3681     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_ON_TOUCH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3682     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_ON_TOUCH, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3683     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_STATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3684     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3685     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3686     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3687     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3688     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3689 
3690     ArkUI_NumberValue opacityTransition[] = {{.f32 = val0}, {.i32 = 1000}, {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = 1000},
3691         {.i32 = 1}, {.i32 = ARKUI_ANIMATION_PLAY_MODE_NORMAL}, {.f32 = val1}};
3692     ArkUI_AttributeItem opacityTransitionItem =
3693         {opacityTransition, sizeof(opacityTransition) / sizeof(ArkUI_NumberValue)};
3694     opacityTransition[6].f32 = negativeFloat;
3695     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3696         ARKUI_ERROR_CODE_PARAM_INVALID);
3697     opacityTransition[5].i32 = negativeEnum;
3698     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3699         ARKUI_ERROR_CODE_PARAM_INVALID);
3700     opacityTransition[5].i32 = static_cast<int32_t>(ARKUI_ANIMATION_PLAY_MODE_ALTERNATE_REVERSE) + 1;
3701     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3702         ARKUI_ERROR_CODE_PARAM_INVALID);
3703     opacityTransition[2].i32 = negativeEnum;
3704     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3705         ARKUI_ERROR_CODE_PARAM_INVALID);
3706     opacityTransition[2].i32 = static_cast<int32_t>(ARKUI_CURVE_FRICTION) + 1;
3707     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3708         ARKUI_ERROR_CODE_PARAM_INVALID);
3709 
3710     valueEnum4[0].i32 = 0;
3711     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BLEND_MODE, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3712     valueEnum4[2].i32 = 0;
3713     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LAYOUT_RECT, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3714     valueEnum4[0].u32 = 0;
3715     valueEnum4[1].u32 = 0;
3716     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &itemEnum4), ARKUI_ERROR_CODE_NO_ERROR);
3717     valueEnum4[1].u32 = 20;
3718     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3719     valueEnum4[0].u32 = 20;
3720     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3721     valueEnum[0].u32 = -1;
3722     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ROLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3723     item0.size = -1;
3724     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3725     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3726     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3727     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3728     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3729     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3730     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3731     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3732     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OUTLINE_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3733     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3734     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3735     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3736     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_SHOW_COUNTER, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3737     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGN_RULES, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3738 
3739     value[0].f32 = 2.0f;
3740     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3741     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3742     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3743     valueEnum[0].i32 = static_cast<int32_t>(MAX_NODE_SCOPE_NUM);
3744     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3745     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBILITY, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3746     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3747     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3748     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SHADOW, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3749     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DIRECTION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3750     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGN_SELF, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3751     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_FIT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3752     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3753     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3754     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_MAX_LENGTH, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3755     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_ENTER_KEY_TYPE, &itemEnum),
3756         ARKUI_ERROR_CODE_PARAM_INVALID);
3757     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_TYPE, &itemEnum),
3758         ARKUI_ERROR_CODE_PARAM_INVALID);
3759     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_TYPE, &itemEnum),
3760         ARKUI_ERROR_CODE_PARAM_INVALID);
3761     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, &itemEnum),
3762         ARKUI_ERROR_CODE_PARAM_INVALID);
3763     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, &itemEnum),
3764         ARKUI_ERROR_CODE_PARAM_INVALID);
3765     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_EDITING, &itemEnum),
3766         ARKUI_ERROR_CODE_PARAM_INVALID);
3767     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_EDITING, &itemEnum),
3768         ARKUI_ERROR_CODE_PARAM_INVALID);
3769     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CANCEL_BUTTON, &itemEnum),
3770         ARKUI_ERROR_CODE_PARAM_INVALID);
3771     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_STACK_ALIGN_CONTENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3772     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3773     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3774     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3775     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CASE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3776     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3777     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_OVERFLOW, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3778     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT, &itemEnum),
3779         ARKUI_ERROR_CODE_PARAM_INVALID);
3780     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_FIT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3781     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_INTERPOLATION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3782     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3783     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_RENDER_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3784     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3785     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &itemEnum),
3786         ARKUI_ERROR_CODE_PARAM_INVALID);
3787     valueEnum4[0].i32 = static_cast<int32_t>(MAX_NODE_SCOPE_NUM);
3788     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3789     valueEnum[0].u32 = static_cast<int32_t>(MAX_NODE_SCOPE_NUM);
3790     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ACTIONS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3791     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CARET_COLOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3792     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_COLOR, &itemEnum),
3793         ARKUI_ERROR_CODE_PARAM_INVALID);
3794     valueEnum[0].i32 = true;
3795     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_STATUS, &itemEnum), ARKUI_ERROR_CODE_NO_ERROR);
3796     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3797     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_COPY_OPTION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3798 
3799     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FOCUS_STATUS), nullptr);
3800     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_OUTLINE_WIDTH), nullptr);
3801     nodeAPI->disposeNode(rootNode);
3802 }
3803 
3804 /**
3805  * @tc.name: NativeNodeTest038
3806  * @tc.desc: Test abnormalInputForText function.
3807  * @tc.type: FUNC
3808  */
3809 HWTEST_F(NativeNodeTest, NativeNodeTest038, TestSize.Level1)
3810 {
3811     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3812         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3813     auto rootNode = new ArkUI_Node({ARKUI_NODE_TEXT, nullptr, true});
3814     float negativeFloat = -1.0f;
3815     int32_t negativeInt = -1;
3816     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3817     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3818     ArkUI_NumberValue value0[] = {};
3819     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3820     ArkUI_NumberValue value4[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
3821         {.f32 = negativeFloat}};
3822     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3823     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
3824     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3825     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CONTENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3826     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3827     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3828     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3829     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3830     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3831     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_HEIGHT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3832     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3833     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3834     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CASE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3835     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CASE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3836     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_LETTER_SPACING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3837     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_LINES, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3838     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3839     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3840     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_OVERFLOW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3841     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_OVERFLOW, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3842     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_FAMILY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3843     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_COPY_OPTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3844     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_BASELINE_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3845     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_TEXT_SHADOW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3846     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3847     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3848     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3849     value4[1].i32 = negativeInt;
3850     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3851     value4[1].i32 = 0;
3852     value4[2].i32 = negativeInt;
3853     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3854     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY, &item0),
3855         ARKUI_ERROR_CODE_PARAM_INVALID);
3856     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY, &itemEnum),
3857         ARKUI_ERROR_CODE_PARAM_INVALID);
3858     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INDENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3859     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_WORD_BREAK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3860     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ELLIPSIS_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3861     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_SPACING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3862     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_SPACING, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3863     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT_FEATURE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3864     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ENABLE_DATA_DETECTOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3865     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_SELECTED_BACKGROUND_COLOR, &item0),
3866         ARKUI_ERROR_CODE_PARAM_INVALID);
3867     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CONTENT_WITH_STYLED_STRING, &item0),
3868         ARKUI_ERROR_CODE_PARAM_INVALID);
3869     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CONTENT_WITH_STYLED_STRING, nullptr),
3870         ARKUI_ERROR_CODE_PARAM_INVALID);
3871     nodeAPI->disposeNode(rootNode);
3872 }
3873 
3874 /**
3875  * @tc.name: NativeNodeTest039
3876  * @tc.desc: Test abnormalInputForTextField function.
3877  * @tc.type: FUNC
3878  */
3879 HWTEST_F(NativeNodeTest, NativeNodeTest039, TestSize.Level1)
3880 {
3881     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3882         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3883     auto textinput = new ArkUI_Node({ARKUI_NODE_TEXT_INPUT, nullptr, true});
3884     auto textarea = new ArkUI_Node({ARKUI_NODE_TEXT_AREA, nullptr, true});
3885     float negativeFloat = -1.0f;
3886     int32_t negativeInt = -1;
3887     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3888     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3889     ArkUI_NumberValue value0[] = {};
3890     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3891     ArkUI_NumberValue value4[] = {{.f32 = 0.0f}, {.i32 = negativeInt}, {.i32 = negativeInt},
3892         {.i32 = negativeInt}};
3893     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3894     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
3895     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3896 
3897     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CARET_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3898     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CARET_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3899     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_UNDERLINE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3900     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_UNDERLINE, &itemEnum),
3901         ARKUI_ERROR_CODE_PARAM_INVALID);
3902     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_MAX_LENGTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3903     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_MAX_LENGTH, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3904     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENTER_KEY_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3905     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENTER_KEY_TYPE, &itemEnum),
3906         ARKUI_ERROR_CODE_PARAM_INVALID);
3907     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_PLACEHOLDER_COLOR, &item0),
3908         ARKUI_ERROR_CODE_PARAM_INVALID);
3909     EXPECT_EQ(nodeAPI->setAttribute(
3910         textinput, NODE_TEXT_INPUT_PLACEHOLDER_FONT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3911     EXPECT_EQ(nodeAPI->setAttribute(
3912         textinput, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3913     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, &item0),
3914         ARKUI_ERROR_CODE_PARAM_INVALID);
3915     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, &itemEnum),
3916         ARKUI_ERROR_CODE_PARAM_INVALID);
3917     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3918     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_TYPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3919     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SELECTED_BACKGROUND_COLOR, &item0),
3920         ARKUI_ERROR_CODE_PARAM_INVALID);
3921     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, &item0),
3922         ARKUI_ERROR_CODE_PARAM_INVALID);
3923     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, &itemEnum),
3924         ARKUI_ERROR_CODE_PARAM_INVALID);
3925     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_EDITING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3926     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_EDITING, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3927     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CANCEL_BUTTON, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3928     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CANCEL_BUTTON, &itemEnum),
3929         ARKUI_ERROR_CODE_PARAM_INVALID);
3930     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_TEXT_SELECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3931     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_UNDERLINE_COLOR, &item0),
3932         ARKUI_ERROR_CODE_PARAM_INVALID);
3933     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENABLE_AUTO_FILL, &item0),
3934         ARKUI_ERROR_CODE_PARAM_INVALID);
3935     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CONTENT_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3936     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SELECT_ALL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3937     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3938     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CARET_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3939     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SELECTION_MENU_HIDDEN, &item0),
3940         ARKUI_ERROR_CODE_PARAM_INVALID);
3941     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SELECTION_MENU_HIDDEN, &itemEnum),
3942         ARKUI_ERROR_CODE_PARAM_INVALID);
3943     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_BLUR_ON_SUBMIT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3944     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CUSTOM_KEYBOARD, &item0),
3945         ARKUI_ERROR_CODE_PARAM_INVALID);
3946     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_WORD_BREAK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3947     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_KEYBOARD_ON_FOCUS, &item0),
3948         ARKUI_ERROR_CODE_PARAM_INVALID);
3949     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_NUMBER_OF_LINES, &item0),
3950         ARKUI_ERROR_CODE_PARAM_INVALID);
3951 
3952     EXPECT_EQ(nodeAPI->setAttribute(
3953         textarea, NODE_TEXT_AREA_PLACEHOLDER_FONT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3954     EXPECT_EQ(nodeAPI->setAttribute(
3955         textarea, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3956     EXPECT_EQ(nodeAPI->setAttribute(
3957         textarea, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3958     value4[1].i32 = ARKUI_FONT_STYLE_ITALIC;
3959     EXPECT_EQ(nodeAPI->setAttribute(
3960         textarea, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3961     EXPECT_EQ(nodeAPI->setAttribute(
3962         textinput, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3963     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_EDITING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3964     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_TYPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3965     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_SHOW_COUNTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3966     value4[0].i32 = negativeInt;
3967     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_SHOW_COUNTER, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3968     value4[0].i32 = 0;
3969     value4[1].f32 = negativeFloat;
3970     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_SHOW_COUNTER, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3971     value4[1].f32 = 1.0f;
3972     value4[2].i32 = negativeInt;
3973     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_SHOW_COUNTER, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3974     EXPECT_EQ(nodeAPI->setAttribute(
3975         textarea, NODE_TEXT_AREA_SELECTION_MENU_HIDDEN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3976     EXPECT_EQ(nodeAPI->setAttribute(
3977         textarea, NODE_TEXT_AREA_SELECTION_MENU_HIDDEN, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3978     nodeAPI->disposeNode(textinput);
3979     nodeAPI->disposeNode(textarea);
3980 }
3981 
3982 /**
3983  * @tc.name: NativeNodeTest040
3984  * @tc.desc: Test abnormalInputForWaterflow function.
3985  * @tc.type: FUNC
3986  */
3987 HWTEST_F(NativeNodeTest, NativeNodeTest040, TestSize.Level1)
3988 {
3989     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3990         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3991     auto rootNode = nodeAPI->createNode(ARKUI_NODE_WATER_FLOW);
3992     float negativeFloat = -1.0f;
3993     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3994     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3995     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3996     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3997     nodeAPI->disposeNode(rootNode);
3998 }
3999 
4000 /**
4001  * @tc.name: NativeNodeTest041
4002  * @tc.desc: Test abnormalInputForGrid function.
4003  * @tc.type: FUNC
4004  */
4005 HWTEST_F(NativeNodeTest, NativeNodeTest041, TestSize.Level1)
4006 {
4007     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4008         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4009     auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID);
4010     float negativeFloat = -1.0f;
4011     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
4012     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
4013     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_GAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4014     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_GAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4015     nodeAPI->disposeNode(rootNode);
4016 }
4017 
4018 /**
4019  * @tc.name: NativeNodeTest042
4020  * @tc.desc: Test abnormalInputForSpan function.
4021  * @tc.type: FUNC
4022  */
4023 HWTEST_F(NativeNodeTest, NativeNodeTest042, TestSize.Level1)
4024 {
4025     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4026         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4027     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SPAN);
4028     float negativeFloat = -1.0f;
4029     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
4030     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4031     ArkUI_NumberValue value0[] = {};
4032     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4033     ArkUI_NumberValue value4[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
4034         {.f32 = negativeFloat}};
4035     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4036     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SPAN_CONTENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4037     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4038     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4039     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
4040     nodeAPI->disposeNode(rootNode);
4041 }
4042 
4043 /**
4044  * @tc.name: NativeNodeTest043
4045  * @tc.desc: Test abnormalInputForImageSpan function.
4046  * @tc.type: FUNC
4047  */
4048 HWTEST_F(NativeNodeTest, NativeNodeTest043, TestSize.Level1)
4049 {
4050     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4051         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4052     auto rootNode = new ArkUI_Node({ARKUI_NODE_IMAGE_SPAN, nullptr, true});
4053     int32_t negativeInt = -1;
4054     ArkUI_NumberValue value0[] = {};
4055     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4056     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4057     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4058     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_SRC, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4059     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT, &item0),
4060         ARKUI_ERROR_CODE_PARAM_INVALID);
4061     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT, &itemEnum),
4062         ARKUI_ERROR_CODE_PARAM_INVALID);
4063     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_ALT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4064     nodeAPI->disposeNode(rootNode);
4065 }
4066 
4067 /**
4068  * @tc.name: NativeNodeTest044
4069  * @tc.desc: Test abnormalInputForImage function.
4070  * @tc.type: FUNC
4071  */
4072 HWTEST_F(NativeNodeTest, NativeNodeTest044, TestSize.Level1)
4073 {
4074     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4075         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4076     auto rootNode = new ArkUI_Node({ARKUI_NODE_IMAGE, nullptr, true});
4077     int32_t negativeInt = -1;
4078     ArkUI_NumberValue value0[] = {};
4079     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4080     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4081     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4082     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SRC, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4083     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_FIT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4084     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_FIT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4085     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_INTERPOLATION, &itemEnum),
4086         ARKUI_ERROR_CODE_PARAM_INVALID);
4087     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_INTERPOLATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4088     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4089     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4090     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_COLOR_FILTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4091     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_AUTO_RESIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4092     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ALT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4093     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_DRAGGABLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4094     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_RENDER_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4095     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_RENDER_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4096     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4097     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4098     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_FILL_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4099     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_RESIZABLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4100     nodeAPI->disposeNode(rootNode);
4101 }
4102 
4103 /**
4104  * @tc.name: NativeNodeTest045
4105  * @tc.desc: Test abnormalInputForToggle function.
4106  * @tc.type: FUNC
4107  */
4108 HWTEST_F(NativeNodeTest, NativeNodeTest045, TestSize.Level1)
4109 {
4110     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4111         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4112     auto rootNode = nodeAPI->createNode(ARKUI_NODE_TOGGLE);
4113     ArkUI_NumberValue value0[] = {};
4114     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4115     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TOGGLE_SELECTED_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4116     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TOGGLE_SWITCH_POINT_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4117     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TOGGLE_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4118     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TOGGLE_UNSELECTED_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4119     nodeAPI->disposeNode(rootNode);
4120 }
4121 
4122 /**
4123  * @tc.name: NativeNodeTest046
4124  * @tc.desc: Test abnormalInputForLoadingProgress function.
4125  * @tc.type: FUNC
4126  */
4127 HWTEST_F(NativeNodeTest, NativeNodeTest046, TestSize.Level1)
4128 {
4129     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4130         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4131     auto rootNode = nodeAPI->createNode(ARKUI_NODE_LOADING_PROGRESS);
4132     ArkUI_NumberValue value0[] = {};
4133     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4134     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LOADING_PROGRESS_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4135     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LOADING_PROGRESS_ENABLE_LOADING, &item0),
4136         ARKUI_ERROR_CODE_PARAM_INVALID);
4137     nodeAPI->disposeNode(rootNode);
4138 }
4139 
4140 /**
4141  * @tc.name: NativeNodeTest047
4142  * @tc.desc: Test abnormalInputForButton function.
4143  * @tc.type: FUNC
4144  */
4145 HWTEST_F(NativeNodeTest, NativeNodeTest047, TestSize.Level1)
4146 {
4147     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4148         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4149     auto rootNode = new ArkUI_Node({ARKUI_NODE_BUTTON, nullptr, true});
4150     int32_t negativeInt = -1;
4151     ArkUI_NumberValue value0[] = {};
4152     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4153     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4154     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4155     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BUTTON_LABEL, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4156     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BUTTON_LABEL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4157     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BUTTON_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4158     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BUTTON_TYPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4159     nodeAPI->disposeNode(rootNode);
4160 }
4161 
4162 /**
4163  * @tc.name: NativeNodeTest048
4164  * @tc.desc: Test abnormalInputForProgress function.
4165  * @tc.type: FUNC
4166  */
4167 HWTEST_F(NativeNodeTest, NativeNodeTest048, TestSize.Level1)
4168 {
4169     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4170         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4171     auto rootNode = nodeAPI->createNode(ARKUI_NODE_PROGRESS);
4172     ArkUI_NumberValue value0[] = {};
4173     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4174     ArkUI_NumberValue value[] = {{.f32 = -1.0f}};
4175     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4176     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4177     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_VALUE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4178     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TOTAL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4179     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TOTAL, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4180     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4181     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4182     value[0].i32 = -1;
4183     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TYPE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4184     nodeAPI->disposeNode(rootNode);
4185 }
4186 
4187 /**
4188  * @tc.name: NativeNodeTest049
4189  * @tc.desc: Test abnormalInputForCheckbox function.
4190  * @tc.type: FUNC
4191  */
4192 HWTEST_F(NativeNodeTest, NativeNodeTest049, TestSize.Level1)
4193 {
4194     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4195         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4196     auto rootNode = nodeAPI->createNode(ARKUI_NODE_CHECKBOX);
4197     uint32_t color = 0xFFFF0000;
4198     float negativeFloat = -1.0f;
4199     ArkUI_NumberValue value0[] = {};
4200     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4201     ArkUI_NumberValue value[] = {{.i32 = -1}};
4202     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4203     ArkUI_NumberValue mark[] = {{.u32 = color}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
4204     ArkUI_AttributeItem markItem = {mark, sizeof(mark) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4205     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SELECT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4206     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SELECT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4207     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SELECT_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4208     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_UNSELECT_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4209     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_MARK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4210     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_MARK, &markItem), ARKUI_ERROR_CODE_PARAM_INVALID);
4211     mark[1].f32 = 0.0f;
4212     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_MARK, &markItem), ARKUI_ERROR_CODE_PARAM_INVALID);
4213     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SHAPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4214     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SHAPE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4215     nodeAPI->disposeNode(rootNode);
4216 }
4217 
4218 /**
4219  * @tc.name: NativeNodeTest050
4220  * @tc.desc: Test abnormalInputForXComponent function.
4221  * @tc.type: FUNC
4222  */
4223 HWTEST_F(NativeNodeTest, NativeNodeTest050, TestSize.Level1)
4224 {
4225     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4226         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4227     auto rootNode = nodeAPI->createNode(ARKUI_NODE_XCOMPONENT);
4228     ArkUI_NumberValue value0[] = {};
4229     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4230     ArkUI_NumberValue value[] = {{.i32 = -1}};
4231     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4232     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_ID, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4233     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_ID, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4234     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4235     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4236     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_SURFACE_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4237     nodeAPI->disposeNode(rootNode);
4238 }
4239 
4240 /**
4241  * @tc.name: NativeNodeTest051
4242  * @tc.desc: Test abnormalInputForDatePicker function.
4243  * @tc.type: FUNC
4244  */
4245 HWTEST_F(NativeNodeTest, NativeNodeTest051, TestSize.Level1)
4246 {
4247     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4248         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4249     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
4250     float negativeFloat = -1.0f;
4251     int32_t negativeInt = -1;
4252     ArkUI_NumberValue value0[] = {};
4253     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4254     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
4255     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test", nullptr};
4256     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4257     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4258     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_LUNAR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4259     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_LUNAR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4260     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_START, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4261     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_START, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4262     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_END, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4263     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_END, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4264     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4265     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4266     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4267         ARKUI_ERROR_CODE_PARAM_INVALID);
4268     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item0),
4269         ARKUI_ERROR_CODE_PARAM_INVALID);
4270     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4271     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4272     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item0),
4273         ARKUI_ERROR_CODE_PARAM_INVALID);
4274     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
4275         ARKUI_ERROR_CODE_PARAM_INVALID);
4276     item.string = "test;10;normal;test;italic";
4277     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
4278         ARKUI_ERROR_CODE_NO_ERROR);
4279     item.string = "#ff182431;test;normal;test;italic";
4280     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
4281         ARKUI_ERROR_CODE_PARAM_INVALID);
4282     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4283     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4284         ARKUI_ERROR_CODE_PARAM_INVALID);
4285     nodeAPI->disposeNode(rootNode);
4286 }
4287 
4288 /**
4289  * @tc.name: NativeNodeTest052
4290  * @tc.desc: Test abnormalInputForTimePicker function.
4291  * @tc.type: FUNC
4292  */
4293 HWTEST_F(NativeNodeTest, NativeNodeTest052, TestSize.Level1)
4294 {
4295     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4296         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4297     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
4298     float negativeFloat = -1.0f;
4299     ArkUI_NumberValue value0[] = {};
4300     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4301     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
4302     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test", nullptr};
4303     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4304     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4305     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_USE_MILITARY_TIME, &item0),
4306         ARKUI_ERROR_CODE_PARAM_INVALID);
4307     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, &item0),
4308         ARKUI_ERROR_CODE_PARAM_INVALID);
4309     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4310         ARKUI_ERROR_CODE_PARAM_INVALID);
4311     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE, &item0),
4312         ARKUI_ERROR_CODE_PARAM_INVALID);
4313     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE, &item),
4314         ARKUI_ERROR_CODE_PARAM_INVALID);
4315     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item0),
4316         ARKUI_ERROR_CODE_PARAM_INVALID);
4317     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item),
4318         ARKUI_ERROR_CODE_PARAM_INVALID);
4319     item.string = "#ff182431;test;normal;test;italic";
4320     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item),
4321         ARKUI_ERROR_CODE_PARAM_INVALID);
4322     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE, &item),
4323         ARKUI_ERROR_CODE_PARAM_INVALID);
4324     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4325         ARKUI_ERROR_CODE_PARAM_INVALID);
4326     item.string = "50-60";
4327     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4328     item.string = "10-60";
4329     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4330     nodeAPI->disposeNode(rootNode);
4331 }
4332 
4333 /**
4334  * @tc.name: NativeNodeTest053
4335  * @tc.desc: Test abnormalInputForTextPicker function.
4336  * @tc.type: FUNC
4337  */
4338 HWTEST_F(NativeNodeTest, NativeNodeTest053, TestSize.Level1)
4339 {
4340     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4341         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4342     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
4343     ArkUI_NumberValue value0[] = {};
4344     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4345     ArkUI_NumberValue value[] = {{.i32 = ARKUI_TEXTPICKER_RANGETYPE_SINGLE}};
4346     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4347     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4348     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4349     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_SELECTED, &item0),
4350         ARKUI_ERROR_CODE_PARAM_INVALID);
4351     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_VALUE, &item0),
4352         ARKUI_ERROR_CODE_PARAM_INVALID);
4353     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item0),
4354         ARKUI_ERROR_CODE_PARAM_INVALID);
4355     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE, &item0),
4356         ARKUI_ERROR_CODE_PARAM_INVALID);
4357     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item0),
4358         ARKUI_ERROR_CODE_PARAM_INVALID);
4359     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_INDEX, &item0),
4360         ARKUI_ERROR_CODE_PARAM_INVALID);
4361     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_CAN_LOOP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4362     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DEFAULT_PICKER_ITEM_HEIGHT, &item0),
4363         ARKUI_ERROR_CODE_PARAM_INVALID);
4364     item.string = "test";
4365     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4366         ARKUI_ERROR_CODE_PARAM_INVALID);
4367     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE, &item),
4368         ARKUI_ERROR_CODE_PARAM_INVALID);
4369     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item),
4370         ARKUI_ERROR_CODE_PARAM_INVALID);
4371     item.string = "#ff182431;test;normal;test;italic";
4372     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4373         ARKUI_ERROR_CODE_PARAM_INVALID);
4374     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE, &item),
4375         ARKUI_ERROR_CODE_PARAM_INVALID);
4376     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item),
4377         ARKUI_ERROR_CODE_PARAM_INVALID);
4378     nodeAPI->disposeNode(rootNode);
4379 }
4380 
4381 /**
4382  * @tc.name: NativeNodeTest054
4383  * @tc.desc: Test abnormalInputForCalendarPicker function.
4384  * @tc.type: FUNC
4385  */
4386 HWTEST_F(NativeNodeTest, NativeNodeTest054, TestSize.Level1)
4387 {
4388     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4389         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4390     auto rootNode = nodeAPI->createNode(ARKUI_NODE_CALENDAR_PICKER);
4391     float negativeFloat = -1.0f;
4392     int32_t negativeInt = -1;
4393     ArkUI_NumberValue value0[] = {};
4394     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4395     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
4396     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4397     ArkUI_NumberValue value3[] = {{.u32 = 2024}, {.u32 = 13}, {.u32 = 1}};
4398     ArkUI_AttributeItem item3 = {value3, sizeof(value3) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4399     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS, &item0),
4400         ARKUI_ERROR_CODE_PARAM_INVALID);
4401     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS, &item),
4402         ARKUI_ERROR_CODE_PARAM_INVALID);
4403     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE, &item0),
4404         ARKUI_ERROR_CODE_PARAM_INVALID);
4405     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE, &item3),
4406         ARKUI_ERROR_CODE_PARAM_INVALID);
4407     value3[1].u32 = 12;
4408     value3[2].u32 = 40;
4409     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE, &item3),
4410         ARKUI_ERROR_CODE_PARAM_INVALID);
4411     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &item0),
4412         ARKUI_ERROR_CODE_PARAM_INVALID);
4413     value[0].i32 = negativeInt;
4414     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &item),
4415         ARKUI_ERROR_CODE_PARAM_INVALID);
4416     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item0),
4417         ARKUI_ERROR_CODE_NO_ERROR);
4418     value3[1].f32 = negativeFloat;
4419     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item3),
4420         ARKUI_ERROR_CODE_PARAM_INVALID);
4421     value3[1].f32 = 1.0f;
4422     value3[2].i32 = negativeInt;
4423     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item3),
4424         ARKUI_ERROR_CODE_PARAM_INVALID);
4425     nodeAPI->disposeNode(rootNode);
4426 }
4427 
4428 /**
4429  * @tc.name: NativeNodeTest055
4430  * @tc.desc: Test abnormalInputForSlider function.
4431  * @tc.type: FUNC
4432  */
4433 HWTEST_F(NativeNodeTest, NativeNodeTest055, TestSize.Level1)
4434 {
4435     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4436         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4437     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SLIDER);
4438     float negativeFloat = -1.0f;
4439     ArkUI_NumberValue value0[] = {};
4440     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4441     ArkUI_NumberValue value[] = {{.i32 = ARKUI_SLIDER_BLOCK_STYLE_IMAGE }, {.i32 = ARKUI_CLIP_TYPE_PATH},
4442         {.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
4443     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4444     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4445     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4446     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_SELECTED_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4447     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_SHOW_STEPS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4448     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4449     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_MIN_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4450     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_MAX_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4451     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_STEP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4452     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_DIRECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4453     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_REVERSE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4454     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4455     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4456     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4457     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4458     value[0].i32 = ARKUI_SLIDER_BLOCK_STYLE_SHAPE;
4459     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4460     value[1].i32 = ARKUI_CLIP_TYPE_RECTANGLE;
4461     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4462     value[0].i32 = -1;
4463     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_SHOW_STEPS, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4464     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_DIRECTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4465     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_REVERSE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4466     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4467     value[0].f32 = -1.0f;
4468     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_STEP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4469     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4470     nodeAPI->disposeNode(rootNode);
4471 }
4472 
4473 /**
4474  * @tc.name: NativeNodeTest056
4475  * @tc.desc: Test abnormalInputForRadio function.
4476  * @tc.type: FUNC
4477  */
4478 HWTEST_F(NativeNodeTest, NativeNodeTest056, TestSize.Level1)
4479 {
4480     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4481         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4482     auto rootNode = nodeAPI->createNode(ARKUI_NODE_RADIO);
4483     ArkUI_NumberValue value0[] = {};
4484     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4485     ArkUI_NumberValue value[] = {{.i32 = -1 }};
4486     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4487     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_CHECKED, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4488     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_CHECKED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4489     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4490     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4491     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_GROUP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4492     item0.size = -1;
4493     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_STYLE, &item0), ARKUI_ERROR_CODE_NO_ERROR);
4494     nodeAPI->disposeNode(rootNode);
4495 }
4496 
4497 /**
4498  * @tc.name: NativeNodeTest057
4499  * @tc.desc: Test abnormalInputForStack function.
4500  * @tc.type: FUNC
4501  */
4502 HWTEST_F(NativeNodeTest, NativeNodeTest057, TestSize.Level1)
4503 {
4504     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4505         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4506     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
4507     ArkUI_NumberValue value0[] = {};
4508     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4509     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_STACK_ALIGN_CONTENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4510     nodeAPI->disposeNode(rootNode);
4511 }
4512 
4513 /**
4514  * @tc.name: NativeNodeTest058
4515  * @tc.desc: Test abnormalInputForScroll function.
4516  * @tc.type: FUNC
4517  */
4518 HWTEST_F(NativeNodeTest, NativeNodeTest058, TestSize.Level1)
4519 {
4520     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4521         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4522     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SCROLL);
4523     float negativeFloat = -1.0f;
4524     int32_t negativeInt = -1;
4525     ArkUI_NumberValue value0[] = {};
4526     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4527     ArkUI_NumberValue value[] = {{.i32 = negativeInt }, {.i32 = negativeInt},
4528         {.i32 = negativeInt}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
4529     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4530     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4531     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4532     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4533     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4534     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4535     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4536     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4537     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item0),
4538         ARKUI_ERROR_CODE_PARAM_INVALID);
4539     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item),
4540         ARKUI_ERROR_CODE_PARAM_INVALID);
4541     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4542     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4543     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4544     value[0].i32 = ARKUI_SCROLL_SNAP_ALIGN_NONE;
4545     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4546     value[1].i32 = true;
4547     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4548     value[2].i32 = true;
4549     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4550     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4551     value[0].i32 = negativeInt;
4552     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4553     value[0].i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY;
4554     value[1].i32 = negativeInt;
4555     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4556     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4557     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4558     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4559     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4560     value[0].i32 = negativeInt;
4561     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4562     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4563     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4564     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4565     value[0].f32 = negativeFloat;
4566     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4567     nodeAPI->disposeNode(rootNode);
4568 }
4569 
4570 /**
4571  * @tc.name: NativeNodeTest059
4572  * @tc.desc: Test abnormalInputForList function.
4573  * @tc.type: FUNC
4574  */
4575 HWTEST_F(NativeNodeTest, NativeNodeTest059, TestSize.Level1)
4576 {
4577     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4578         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4579     auto rootNode = new ArkUI_Node({ARKUI_NODE_LIST, nullptr, true});
4580     auto childNode = new ArkUI_Node({ARKUI_NODE_LIST_ITEM, nullptr, true});
4581     auto childNodeNew = new ArkUI_Node({ARKUI_NODE_LIST_ITEM, nullptr, true});
4582     auto groupNode = new ArkUI_Node({ARKUI_NODE_LIST_ITEM_GROUP, nullptr, true});
4583 
4584     nodeAPI->insertChildAt(rootNode, groupNode, 0);
4585     nodeAPI->insertChildAfter(groupNode, childNodeNew, nullptr);
4586     nodeAPI->insertChildBefore(groupNode, childNode, childNodeNew);
4587     float negativeFloat = -1.0f;
4588     int32_t negativeInt = -1;
4589     ArkUI_NumberValue value0[] = {};
4590     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4591     ArkUI_NumberValue value[] = {{.i32 = negativeInt }, {.i32 = negativeInt},
4592         {.i32 = negativeInt}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
4593     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4594     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4595     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4596     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIRECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4597     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIRECTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4598     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_STICKY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4599     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_STICKY, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4600     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_SPACE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4601     value[0].f32 = negativeFloat;
4602     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_SPACE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4603     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_NODE_ADAPTER, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4604     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_NODE_ADAPTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4605     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CACHED_COUNT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4606     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CACHED_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4607     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CACHED_COUNT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4608     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_SCROLL_TO_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4609     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4610     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4611     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4612     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CHILDREN_MAIN_SIZE, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4613     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CHILDREN_MAIN_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4614     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_INITIAL_INDEX, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4615     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_INITIAL_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4616     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_INITIAL_INDEX, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4617     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4618     value[1].f32 = negativeFloat;
4619     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4620     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &item),
4621         ARKUI_ERROR_CODE_PARAM_INVALID);
4622     value[1].f32 = 0.0f;
4623     value[2].f32 = negativeFloat;
4624     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4625     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &item),
4626         ARKUI_ERROR_CODE_PARAM_INVALID);
4627     value[2].f32 = 0.0f;
4628     value[3].f32 = negativeFloat;
4629     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4630     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &item),
4631         ARKUI_ERROR_CODE_PARAM_INVALID);
4632     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_LIST_ITEM_SWIPE_ACTION, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4633     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_LIST_ITEM_SWIPE_ACTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4634     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_HEADER, &item0),
4635         ARKUI_ERROR_CODE_PARAM_INVALID);
4636     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_FOOTER, &item0),
4637         ARKUI_ERROR_CODE_PARAM_INVALID);
4638     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &item0),
4639         ARKUI_ERROR_CODE_PARAM_INVALID);
4640     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_CHILDREN_MAIN_SIZE, nullptr),
4641         ARKUI_ERROR_CODE_PARAM_INVALID);
4642     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_CHILDREN_MAIN_SIZE, &item0),
4643         ARKUI_ERROR_CODE_PARAM_INVALID);
4644     nodeAPI->removeChild(groupNode, childNode);
4645     nodeAPI->disposeNode(rootNode);
4646     nodeAPI->disposeNode(groupNode);
4647     nodeAPI->disposeNode(childNode);
4648 }
4649 
4650 /**
4651  * @tc.name: NativeNodeTest060
4652  * @tc.desc: Test abnormalInputForSwiper function.
4653  * @tc.type: FUNC
4654  */
4655 HWTEST_F(NativeNodeTest, NativeNodeTest060, TestSize.Level1)
4656 {
4657     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4658         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4659     auto rootNode = new ArkUI_Node({ARKUI_NODE_SWIPER, nullptr, true});
4660     float negativeFloat = -1.0f;
4661     int32_t negativeInt = -1;
4662     ArkUI_NumberValue value0[] = {};
4663     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4664     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4665     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4666     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}};
4667     ArkUI_AttributeItem itemFloat = {valueFloat, 1, nullptr, nullptr};
4668     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_LOOP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4669     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_LOOP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4670     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_AUTO_PLAY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4671     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_AUTO_PLAY, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4672     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4673     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4674     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INTERVAL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4675     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INTERVAL, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4676     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_VERTICAL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4677     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_VERTICAL, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4678     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DURATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4679     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DURATION, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4680     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4681     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4682     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_ITEM_SPACE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4683     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_ITEM_SPACE, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4684     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4685     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDEX, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4686     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISPLAY_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4687     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4688     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4689     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4690     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW, &itemFloat),
4691         ARKUI_ERROR_CODE_PARAM_INVALID);
4692     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4693     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4694     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NODE_ADAPTER, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4695     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NODE_ADAPTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4696     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CACHED_COUNT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4697     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CACHED_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4698     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CACHED_COUNT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4699     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4700     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4701     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4702     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4703     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4704     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4705     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR_INTERACTIVE, &item0),
4706         ARKUI_ERROR_CODE_PARAM_INVALID);
4707     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4708     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4709     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SWIPE_TO_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4710     valueEnum[0].i32 = ARKUI_SWIPER_INDICATOR_TYPE_DOT;
4711     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4712     nodeAPI->disposeNode(rootNode);
4713 }
4714 
4715 /**
4716  * @tc.name: NativeNodeTest061
4717  * @tc.desc: Test abnormalInputForColumn function.
4718  * @tc.type: FUNC
4719  */
4720 HWTEST_F(NativeNodeTest, NativeNodeTest061, TestSize.Level1)
4721 {
4722     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4723         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4724     auto rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
4725     int32_t negativeInt = -1;
4726     ArkUI_NumberValue value0[] = {};
4727     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4728     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4729     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4730     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4731     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4732     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4733     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4734     nodeAPI->disposeNode(rootNode);
4735 }
4736 
4737 /**
4738  * @tc.name: NativeNodeTest062
4739  * @tc.desc: Test abnormalInputForRow function.
4740  * @tc.type: FUNC
4741  */
4742 HWTEST_F(NativeNodeTest, NativeNodeTest062, TestSize.Level1)
4743 {
4744     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4745         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4746     auto rootNode = nodeAPI->createNode(ARKUI_NODE_ROW);
4747     ASSERT_NE(rootNode, nullptr);
4748     int32_t negativeInt = -1;
4749     ArkUI_NumberValue value0[] = {};
4750     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4751     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4752     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4753     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROW_ALIGN_ITEMS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4754     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROW_ALIGN_ITEMS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4755     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4756     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4757     nodeAPI->disposeNode(rootNode);
4758 }
4759 
4760 /**
4761  * @tc.name: NativeNodeTest063
4762  * @tc.desc: Test abnormalInputForRefresh function.
4763  * @tc.type: FUNC
4764  */
4765 HWTEST_F(NativeNodeTest, NativeNodeTest063, TestSize.Level1)
4766 {
4767     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4768         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4769     auto rootNode = nodeAPI->createNode(ARKUI_NODE_REFRESH);
4770     ASSERT_NE(rootNode, nullptr);
4771     float negativeFloat = -1.0f;
4772     int32_t negativeInt = -1;
4773     ArkUI_NumberValue value0[] = {};
4774     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4775     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4776     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4777     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}};
4778     ArkUI_AttributeItem itemFloat = {valueFloat, 1, nullptr, nullptr};
4779     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_REFRESHING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4780     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_REFRESHING, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4781     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_CONTENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4782     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4783     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &itemFloat),
4784         ARKUI_ERROR_CODE_PARAM_INVALID);
4785     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4786     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_OFFSET, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4787     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_TO_REFRESH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4788     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_TO_REFRESH, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4789     valueFloat[0].f32 = 2.0f;
4790     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &itemFloat),
4791         ARKUI_ERROR_CODE_PARAM_INVALID);
4792     nodeAPI->disposeNode(rootNode);
4793 }
4794 
4795 /**
4796  * @tc.name: NativeNodeTest064
4797  * @tc.desc: Test abnormalInputForWaterflow function.
4798  * @tc.type: FUNC
4799  */
4800 HWTEST_F(NativeNodeTest, NativeNodeTest064, TestSize.Level1)
4801 {
4802     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4803         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4804     auto rootNode = nodeAPI->createNode(ARKUI_NODE_WATER_FLOW);
4805     ASSERT_NE(rootNode, nullptr);
4806     float negativeFloat = -1.0f;
4807     int32_t negativeInt = -1;
4808     ArkUI_NumberValue value0[] = {};
4809     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4810     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4811     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4812     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
4813         {.f32 = negativeFloat}};
4814     ArkUI_AttributeItem itemFloat = {valueFloat, sizeof(valueFloat) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4815     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION, &item0),
4816         ARKUI_ERROR_CODE_PARAM_INVALID);
4817     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION, &itemEnum),
4818         ARKUI_ERROR_CODE_PARAM_INVALID);
4819     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_TEMPLATE, &item0),
4820         ARKUI_ERROR_CODE_PARAM_INVALID);
4821     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_TEMPLATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4822     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4823     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4824     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4825     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4826     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4827     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4828     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION, &itemFloat),
4829         ARKUI_ERROR_CODE_PARAM_INVALID);
4830     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_NODE_ADAPTER, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4831     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_NODE_ADAPTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4832     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4833     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4834     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4835     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_FOOTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4836     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4837     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE, &item0),
4838         ARKUI_ERROR_CODE_PARAM_INVALID);
4839     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE, &itemEnum),
4840         ARKUI_ERROR_CODE_PARAM_INVALID);
4841     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE, &itemFloat),
4842         ARKUI_ERROR_CODE_PARAM_INVALID);
4843     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_MODE, &itemFloat),
4844         ARKUI_ERROR_CODE_PARAM_INVALID);
4845     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_MODE, &item0),
4846         ARKUI_ERROR_CODE_PARAM_INVALID);
4847     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_MODE, &itemEnum),
4848         ARKUI_ERROR_CODE_PARAM_INVALID);
4849     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_MODE, nullptr),
4850         ARKUI_ERROR_CODE_PARAM_INVALID);
4851     ArkUI_NumberValue layoutModeV[] = {{.i32 = ArkUI_WaterFlowLayoutMode::ARKUI_WATER_FLOW_LAYOUT_MODE_SLIDING_WINDOW}};
4852     ArkUI_AttributeItem layoutModeAttr = {layoutModeV, 1, nullptr, nullptr};
4853     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_MODE, &layoutModeAttr),
4854         ARKUI_ERROR_CODE_NO_ERROR);
4855     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_MODE)->value->i32,
4856         ArkUI_WaterFlowLayoutMode::ARKUI_WATER_FLOW_LAYOUT_MODE_SLIDING_WINDOW);
4857     nodeAPI->disposeNode(rootNode);
4858 }
4859 
4860 /**
4861  * @tc.name: NativeNodeTest065
4862  * @tc.desc: Test abnormalInputForGrid function.
4863  * @tc.type: FUNC
4864  */
4865 HWTEST_F(NativeNodeTest, NativeNodeTest065, TestSize.Level1)
4866 {
4867     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4868         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4869     auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID);
4870     ASSERT_NE(rootNode, nullptr);
4871     float negativeFloat = -1.0f;
4872     int32_t negativeInt = -1;
4873     ArkUI_NumberValue value0[] = {};
4874     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4875     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4876     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4877     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
4878         {.f32 = negativeFloat}};
4879     ArkUI_AttributeItem itemFloat = {valueFloat, sizeof(valueFloat) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4880     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_TEMPLATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4881     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_TEMPLATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4882     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_GAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4883     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_GAP, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4884     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_GAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4885     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_GAP, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4886     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_NODE_ADAPTER, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4887     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_NODE_ADAPTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4888     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_CACHED_COUNT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4889     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_CACHED_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4890     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_CACHED_COUNT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4891     nodeAPI->disposeNode(rootNode);
4892 }
4893 
4894 /**
4895  * @tc.name: NativeNodeTest066
4896  * @tc.desc: Test abnormalInputForImageAnimator function.
4897  * @tc.type: FUNC
4898  */
4899 HWTEST_F(NativeNodeTest, NativeNodeTest066, TestSize.Level1)
4900 {
4901     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4902         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4903     auto rootNode = nodeAPI->createNode(ARKUI_NODE_IMAGE_ANIMATOR);
4904     ASSERT_NE(rootNode, nullptr);
4905     int32_t negativeInt = -1;
4906     ArkUI_NumberValue value0[] = {};
4907     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4908     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4909     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4910     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_IMAGES, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4911     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_IMAGES, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4912     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4913     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4914     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_DURATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4915     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4916     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4917     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4918     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE, &itemEnum),
4919         ARKUI_ERROR_CODE_PARAM_INVALID);
4920     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4921     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE, &itemEnum),
4922         ARKUI_ERROR_CODE_PARAM_INVALID);
4923     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_ITERATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4924     valueEnum[0].i32 = 4;
4925     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4926     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4927     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE, &itemEnum),
4928         ARKUI_ERROR_CODE_PARAM_INVALID);
4929     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE, &itemEnum),
4930         ARKUI_ERROR_CODE_PARAM_INVALID);
4931     nodeAPI->disposeNode(rootNode);
4932 }
4933 
4934 /**
4935  * @tc.name: NativeNodeTest067
4936  * @tc.desc: Test attributeAbnormal function.
4937  * @tc.type: FUNC
4938  */
4939 HWTEST_F(NativeNodeTest, NativeNodeTest067, TestSize.Level1)
4940 {
4941     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4942         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4943     int32_t abnormalType = static_cast<int32_t>(ARKUI_NODE_CUSTOM_SPAN) + 1;
4944     EXPECT_EQ(nodeAPI->createNode(static_cast<ArkUI_NodeType>(abnormalType)), nullptr);
4945     nodeAPI->disposeNode(nullptr);
4946     EXPECT_EQ(nodeAPI->addChild(nullptr, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4947     EXPECT_EQ(nodeAPI->removeChild(nullptr, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4948     EXPECT_EQ(nodeAPI->insertChildAfter(nullptr, nullptr, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4949     EXPECT_EQ(nodeAPI->insertChildBefore(nullptr, nullptr, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4950     EXPECT_EQ(nodeAPI->insertChildAt(nullptr, nullptr, 0), ARKUI_ERROR_CODE_PARAM_INVALID);
4951     EXPECT_EQ(nodeAPI->setAttribute(nullptr, NODE_WIDTH, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4952     EXPECT_EQ(nodeAPI->resetAttribute(nullptr, NODE_WIDTH), ARKUI_ERROR_CODE_PARAM_INVALID);
4953     EXPECT_EQ(nodeAPI->getAttribute(nullptr, NODE_WIDTH), nullptr);
4954     auto abnormalNode = new ArkUI_Node({-1, nullptr, true});
4955     EXPECT_EQ(nodeAPI->addChild(abnormalNode, abnormalNode), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4956     EXPECT_EQ(nodeAPI->removeChild(abnormalNode, abnormalNode), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4957     EXPECT_EQ(nodeAPI->insertChildAfter(abnormalNode, abnormalNode, nullptr),
4958         ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4959     EXPECT_EQ(nodeAPI->insertChildBefore(abnormalNode, abnormalNode, nullptr),
4960         ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4961     EXPECT_EQ(nodeAPI->insertChildAt(abnormalNode, abnormalNode, 0), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4962     EXPECT_EQ(nodeAPI->setAttribute(abnormalNode, NODE_WIDTH, nullptr), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4963     EXPECT_EQ(nodeAPI->resetAttribute(abnormalNode, NODE_WIDTH), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4964     int32_t abnormalAttribute = 999 * MAX_NODE_SCOPE_NUM;
4965     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
4966     EXPECT_EQ(nodeAPI->setAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute), nullptr),
4967         ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4968     EXPECT_EQ(nodeAPI->resetAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)),
4969         ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4970     EXPECT_EQ(nodeAPI->getAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4971     for (int32_t i = 0; i <= static_cast<int32_t>(ARKUI_NODE_IMAGE_ANIMATOR); i++) {
4972         abnormalAttribute = (i + 1) * MAX_NODE_SCOPE_NUM - 1;
4973         EXPECT_EQ(nodeAPI->setAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute), nullptr),
4974             ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4975         EXPECT_EQ(nodeAPI->resetAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)),
4976             ARKUI_ERROR_CODE_NO_ERROR);
4977         if (i == ARKUI_NODE_DATE_PICKER || i == ARKUI_NODE_TEXT_PICKER || i == ARKUI_NODE_TIME_PICKER ||
4978             i == ARKUI_NODE_LOADING_PROGRESS) {
4979             EXPECT_NE(nodeAPI->getAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4980         } else {
4981             EXPECT_EQ(nodeAPI->getAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4982         }
4983     }
4984     for (int32_t j = static_cast<int32_t>(ARKUI_NODE_STACK); j < static_cast<int32_t>(ARKUI_NODE_GRID_ITEM); j++) {
4985         abnormalAttribute = (j + 1) * MAX_NODE_SCOPE_NUM - 1;
4986         if (j == ARKUI_NODE_FLOW_ITEM) {
4987             EXPECT_EQ(nodeAPI->setAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute), nullptr),
4988                 ARKUI_ERROR_CODE_PARAM_INVALID);
4989             EXPECT_EQ(nodeAPI->resetAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)),
4990                 ARKUI_ERROR_CODE_PARAM_INVALID);
4991             EXPECT_EQ(nodeAPI->getAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4992         } else {
4993             EXPECT_EQ(nodeAPI->setAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute), nullptr),
4994                 ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4995             EXPECT_EQ(nodeAPI->resetAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)),
4996                 ARKUI_ERROR_CODE_NO_ERROR);
4997             if (j == ARKUI_NODE_LIST) {
4998                 EXPECT_NE(nodeAPI->getAttribute(
4999                     node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
5000             } else {
5001                 EXPECT_EQ(nodeAPI->getAttribute(
5002                     node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
5003             }
5004         }
5005     }
5006     delete abnormalNode;
5007     abnormalNode = nullptr;
5008     nodeAPI->disposeNode(node);
5009 }
5010 
5011 /**
5012  * @tc.name: NativeNodeTest068
5013  * @tc.desc: Test eventAbnormal function.
5014  * @tc.type: FUNC
5015  */
5016 HWTEST_F(NativeNodeTest, NativeNodeTest068, TestSize.Level1)
5017 {
5018     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5019         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5020     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
5021     EXPECT_EQ(nodeAPI->registerNodeEvent(nullptr, NODE_TOUCH_EVENT, 0, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
5022     EXPECT_EQ(nodeAPI->registerNodeEvent(
5023         node, static_cast<ArkUI_NodeEventType>(-1), 0, nullptr), ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
5024     nodeAPI->unregisterNodeEvent(nullptr, NODE_TOUCH_EVENT);
5025     nodeAPI->unregisterNodeEvent(node, NODE_TOUCH_EVENT);
5026     nodeAPI->disposeNode(node);
5027 }
5028 
5029 /**
5030  * @tc.name: NativeNodeTest069
5031  * @tc.desc: Test lengthMetricUnit function.
5032  * @tc.type: FUNC
5033  */
5034 HWTEST_F(NativeNodeTest, NativeNodeTest069, TestSize.Level1)
5035 {
5036     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5037         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5038     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
5039     EXPECT_EQ(nodeAPI->setLengthMetricUnit(nullptr, ARKUI_LENGTH_METRIC_UNIT_PX), ARKUI_ERROR_CODE_PARAM_INVALID);
5040     EXPECT_EQ(nodeAPI->setLengthMetricUnit(node, static_cast<ArkUI_LengthMetricUnit>(-2)),
5041         ARKUI_ERROR_CODE_PARAM_INVALID);
5042     EXPECT_EQ(nodeAPI->setLengthMetricUnit(node, ARKUI_LENGTH_METRIC_UNIT_PX), ARKUI_ERROR_CODE_NO_ERROR);
5043     ArkUI_NumberValue value[] = {{.f32 = 10.0f}, {.f32 = 10.0f}};
5044     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
5045     nodeAPI->setAttribute(node, NODE_WIDTH, &item);
5046     nodeAPI->setLengthMetricUnit(node, ARKUI_LENGTH_METRIC_UNIT_FP);
5047     EXPECT_EQ(nodeAPI->setAttribute(node, NODE_SCROLL_BY, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
5048     nodeAPI->disposeNode(node);
5049 }
5050 
5051 /**
5052  * @tc.name: NativeNodeTest070
5053  * @tc.desc: Test convertEvent function.
5054  * @tc.type: FUNC
5055  */
5056 HWTEST_F(NativeNodeTest, NativeNodeTest070, TestSize.Level1)
5057 {
5058     ArkUINodeEvent origin;
5059     ArkUI_NodeEvent event;
5060     ArkUI_CompatibleNodeEvent compatibleEvent;
5061     const std::string str = "test";
5062     origin.kind = ArkUIEventCategory::COMPONENT_ASYNC_EVENT;
5063     origin.componentAsyncEvent.subKind = ArkUIEventSubKind::ON_VISIBLE_AREA_CHANGE;
5064     origin.componentAsyncEvent.data[0].i32 = 0;
5065     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5066     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
5067     origin.kind = ArkUIEventCategory::TEXT_INPUT;
5068     origin.textInputEvent.subKind = ArkUIEventSubKind::ON_TEXT_INPUT_CHANGE;
5069     origin.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
5070     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5071     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
5072     origin.kind = ArkUIEventCategory::TOUCH_EVENT;
5073     origin.touchEvent.subKind = ArkUIEventSubKind::ON_TOUCH;
5074     origin.touchEvent.sourceType = 2;
5075     origin.touchEvent.action = 0;
5076     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5077     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
5078     origin.touchEvent.sourceType = 0;
5079     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
5080     origin.touchEvent.action = 1;
5081     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
5082     origin.touchEvent.action = 2;
5083     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
5084     origin.touchEvent.action = 3;
5085     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
5086     origin.touchEvent.action = 4;
5087     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
5088 
5089     origin.kind = ArkUIEventCategory::MOUSE_INPUT_EVENT;
5090     origin.mouseEvent.subKind = ArkUIEventSubKind::ON_MOUSE;
5091     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5092     origin.kind = ArkUIEventCategory::MIXED_EVENT;
5093     origin.mouseEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
5094     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5095     origin.kind = ArkUIEventCategory::INVALID;
5096     origin.mouseEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
5097     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), false);
5098     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), false);
5099 
5100     origin.kind = ArkUIEventCategory::DRAG_EVENT;
5101     origin.dragEvent.subKind = ArkUIEventSubKind::ON_DRAG_START;
5102     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5103     origin.kind = ArkUIEventCategory::KEY_INPUT_EVENT;
5104     origin.dragEvent.subKind = ArkUIEventSubKind::ON_KEY_PREIME;
5105     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5106     origin.kind = ArkUIEventCategory::FOCUS_AXIS_EVENT;
5107     origin.dragEvent.subKind = ArkUIEventSubKind::ON_FOCUS_AXIS;
5108     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5109     origin.kind = ArkUIEventCategory::TEXT_INPUT_CHANGE;
5110     origin.dragEvent.subKind = ArkUIEventSubKind::ON_TEXT_INPUT_CHANGE;
5111     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5112     origin.kind = ArkUIEventCategory::AXIS_EVENT;
5113     origin.dragEvent.subKind = ArkUIEventSubKind::ON_AXIS;
5114     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5115     origin.kind = ArkUIEventCategory::CLICK_EVENT;
5116     origin.dragEvent.subKind = ArkUIEventSubKind::ON_CLICK_EVENT;
5117     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5118     origin.kind = ArkUIEventCategory::HOVER_EVENT;
5119     origin.dragEvent.subKind = ArkUIEventSubKind::ON_HOVER_EVENT;
5120     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
5121 }
5122 
5123 /**
5124  * @tc.name: NativeNodeTest071
5125  * @tc.desc: Test ConvertToCTouch function.
5126  * @tc.type: FUNC
5127  */
5128 HWTEST_F(NativeNodeTest, NativeNodeTest071, TestSize.Level1)
5129 {
5130     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(0), 1);
5131     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(1), 3);
5132     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(2), 2);
5133     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(3), 0);
5134     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(-1), -1);
5135 
5136     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(1), 1);
5137     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(2), 2);
5138     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(7), 3);
5139     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(9), 4);
5140     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(0), 0);
5141 
5142     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(1), 1);
5143     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(2), 2);
5144     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(3), 3);
5145     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(13), 13);
5146     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(0), 0);
5147 
5148     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(1), 1);
5149     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(2), 2);
5150     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(4), 3);
5151     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(8), 4);
5152     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(16), 5);
5153     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(-1), 0);
5154 }
5155 
5156 /**
5157  * @tc.name: NativeNodeTest072
5158  * @tc.desc: Test convertEventResult function.
5159  * @tc.type: FUNC
5160  */
5161 HWTEST_F(NativeNodeTest, NativeNodeTest072, TestSize.Level1)
5162 {
5163     ArkUINodeEvent event;
5164     ArkUI_CompatibleNodeEvent origin;
5165     origin.kind = ArkUI_NodeEventType::NODE_TOUCH_EVENT;
5166     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5167     origin.kind = ArkUI_NodeEventType::NODE_ON_TOUCH_INTERCEPT;
5168     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5169     origin.kind = ArkUI_NodeEventType::NODE_TEXT_INPUT_ON_CHANGE;
5170     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5171     origin.kind = ArkUI_NodeEventType::NODE_TEXT_INPUT_ON_CUT;
5172     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5173     origin.kind = ArkUI_NodeEventType::NODE_TEXT_INPUT_ON_PASTE;
5174     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5175     origin.kind = ArkUI_NodeEventType::NODE_TEXT_AREA_ON_CHANGE;
5176     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5177     origin.kind = ArkUI_NodeEventType::NODE_TEXT_AREA_ON_PASTE;
5178     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5179     origin.kind = ArkUI_NodeEventType::NODE_EVENT_ON_APPEAR;
5180     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5181     origin.kind = ArkUI_NodeEventType::NODE_TEXT_INPUT_ON_CHANGE_WITH_PREVIEW_TEXT;
5182     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5183     origin.kind = ArkUI_NodeEventType::NODE_TEXT_AREA_ON_CHANGE_WITH_PREVIEW_TEXT;
5184     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5185 }
5186 
5187 /**
5188  * @tc.name: NativeNodeTest073
5189  * @tc.desc: Test OH_ArkUI_NodeEvent_GetInputEvent function.
5190  * @tc.type: FUNC
5191  */
5192 HWTEST_F(NativeNodeTest, NativeNodeTest073, TestSize.Level1)
5193 {
5194     ArkUI_NodeEvent event = { 1, 0 };
5195     event.origin = nullptr;
5196     EXPECT_EQ(OH_ArkUI_NodeEvent_GetInputEvent(nullptr), nullptr);
5197     EXPECT_EQ(OH_ArkUI_NodeEvent_GetInputEvent(nullptr), nullptr);
5198     event.category = 0;
5199     EXPECT_EQ(OH_ArkUI_NodeEvent_GetInputEvent(&event), nullptr);
5200 }
5201 
5202 /**
5203  * @tc.name: NativeNodeTest074
5204  * @tc.desc: Test OH_ArkUI_NodeEvent_GetNodeComponentEvent function.
5205  * @tc.type: FUNC
5206  */
5207 HWTEST_F(NativeNodeTest, NativeNodeTest074, TestSize.Level1)
5208 {
5209     ArkUI_NodeEvent event = { 0, 0 };
5210     event.origin = nullptr;
5211     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNodeComponentEvent(nullptr), nullptr);
5212     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNodeComponentEvent(&event), nullptr);
5213     event.category = 1;
5214     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNodeComponentEvent(&event), nullptr);
5215     ArkUINodeEvent origin = { 0, 0, 0};
5216     origin.componentAsyncEvent.subKind = ArkUIEventSubKind::ON_VISIBLE_AREA_CHANGE;
5217     origin.componentAsyncEvent.data[0].i32 = 0;
5218     event.origin = &origin;
5219     EXPECT_NE(OH_ArkUI_NodeEvent_GetNodeComponentEvent(&event), nullptr);
5220 }
5221 
5222 /**
5223  * @tc.name: NativeNodeTest075
5224  * @tc.desc: Test OH_ArkUI_NodeEvent_GetStringAsyncEvent function.
5225  * @tc.type: FUNC
5226  */
5227 HWTEST_F(NativeNodeTest, NativeNodeTest075, TestSize.Level1)
5228 {
5229     ArkUI_NodeEvent event = { 0, 0 };
5230     event.origin = nullptr;
5231     const std::string str = "test";
5232     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringAsyncEvent(nullptr), nullptr);
5233     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringAsyncEvent(&event), nullptr);
5234     event.category = 2;
5235     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringAsyncEvent(&event), nullptr);
5236     ArkUINodeEvent origin = { 0, 0, 0};
5237     origin.textInputEvent.subKind = ArkUIEventSubKind::ON_TEXT_INPUT_CHANGE;
5238     origin.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
5239     event.origin = &origin;
5240     EXPECT_NE(OH_ArkUI_NodeEvent_GetStringAsyncEvent(&event), nullptr);
5241 }
5242 
5243 /**
5244  * @tc.name: NativeNodeTest076
5245  * @tc.desc: Test OH_ArkUI_NodeEvent_GetUserData function.
5246  * @tc.type: FUNC
5247  */
5248 HWTEST_F(NativeNodeTest, NativeNodeTest076, TestSize.Level1)
5249 {
5250     ArkUI_NodeEvent event = { 0, 0 };
5251     event.userData = nullptr;
5252     EXPECT_EQ(OH_ArkUI_NodeEvent_GetUserData(nullptr), nullptr);
5253     EXPECT_EQ(OH_ArkUI_NodeEvent_GetUserData(&event), nullptr);
5254 }
5255 
5256 /**
5257  * @tc.name: NativeNodeTest077
5258  * @tc.desc: Test OH_ArkUI_NodeEvent_GetNumberValue function.
5259  * @tc.type: FUNC
5260  */
5261 HWTEST_F(NativeNodeTest, NativeNodeTest077, TestSize.Level1)
5262 {
5263     ArkUI_NodeEvent event = { 0, 0 };
5264     event.origin = nullptr;
5265     int32_t index = 0;
5266     ArkUI_NumberValue value[] = {{.f32 = 10.0f}};
5267     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(nullptr, index, value), 106108);
5268     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), 106108);
5269     event.category = 3;
5270     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), 106108);
5271     ArkUINodeEvent mixEvent;
5272     mixEvent.kind = ArkUIEventCategory::MIXED_EVENT;
5273     mixEvent.extraParam = reinterpret_cast<intptr_t>(nullptr);
5274     mixEvent.mixedEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
5275     mixEvent.mixedEvent.numberData[0].f32 = 0.0f;
5276     mixEvent.mixedEvent.numberDataLength = 1;
5277     event.origin = &mixEvent;
5278     index = 2;
5279     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), 106107);
5280     index = -1;
5281     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), 106107);
5282     index = 0;
5283     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), ARKUI_ERROR_CODE_NO_ERROR);
5284 }
5285 
5286 /**
5287  * @tc.name: NativeNodeTest078
5288  * @tc.desc: Test OH_ArkUI_NodeEvent_GetStringValue function.
5289  * @tc.type: FUNC
5290  */
5291 HWTEST_F(NativeNodeTest, NativeNodeTest078, TestSize.Level1)
5292 {
5293     ArkUI_NodeEvent event = { 0, 0 };
5294     event.origin = nullptr;
5295     int32_t index = 0;
5296     int32_t size = 0;
5297     char* value[size];
5298     const std::string str1 = "";
5299     const std::string str2 = "test";
5300     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(nullptr, index, value, &size), 106108);
5301     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106108);
5302     event.category = 3;
5303     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106108);
5304     ArkUINodeEvent mixEvent;
5305     mixEvent.kind = ArkUIEventCategory::MIXED_EVENT;
5306     mixEvent.extraParam = reinterpret_cast<intptr_t>(nullptr);
5307     mixEvent.mixedEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
5308     mixEvent.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(str1.c_str());
5309     mixEvent.mixedEvent.stringPtrDataLength = 1;
5310     event.origin = &mixEvent;
5311     index = 2;
5312     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106107);
5313     index = 0;
5314     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106108);
5315     mixEvent.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(str2.c_str());
5316     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106108);
5317 }
5318 
5319 /**
5320  * @tc.name: NativeNodeTest079
5321  * @tc.desc: Test OH_ArkUI_NodeEvent_SetReturnNumberValue function.
5322  * @tc.type: FUNC
5323  */
5324 HWTEST_F(NativeNodeTest, NativeNodeTest079, TestSize.Level1)
5325 {
5326     ArkUI_NodeEvent event = { 0, 0 };
5327     event.origin = nullptr;
5328     int32_t size = 1;
5329     ArkUI_NumberValue value[] = {{.i32 = 10}};
5330     EXPECT_EQ(OH_ArkUI_NodeEvent_SetReturnNumberValue(nullptr, value, size), 106108);
5331     EXPECT_EQ(OH_ArkUI_NodeEvent_SetReturnNumberValue(&event, value, size), 106108);
5332     event.category = 3;
5333     EXPECT_EQ(OH_ArkUI_NodeEvent_SetReturnNumberValue(&event, value, size), 106108);
5334     ArkUINodeEvent mixEvent;
5335     mixEvent.kind = ArkUIEventCategory::MIXED_EVENT;
5336     mixEvent.extraParam = reinterpret_cast<intptr_t>(nullptr);
5337     mixEvent.mixedEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
5338     event.origin = &mixEvent;
5339     EXPECT_EQ(OH_ArkUI_NodeEvent_SetReturnNumberValue(&event, value, size), ARKUI_ERROR_CODE_NO_ERROR);
5340 }
5341 
5342 /**
5343  * @tc.name: NativeNodeTest080
5344  * @tc.desc: Test customSpanNode function.
5345  * @tc.type: FUNC
5346  */
5347 HWTEST_F(NativeNodeTest, NativeNodeTest080, TestSize.Level1)
5348 {
5349     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5350         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5351     auto rootNode = new ArkUI_Node({ARKUI_NODE_CUSTOM_SPAN, nullptr, true});
5352 
5353     EXPECT_EQ(nodeAPI->registerNodeCustomEvent(
5354         rootNode, ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE, 0, nullptr), ARKUI_ERROR_CODE_NO_ERROR);
5355     EXPECT_EQ(nodeAPI->registerNodeCustomEvent(
5356         rootNode, ARKUI_NODE_CUSTOM_EVENT_ON_DRAW, 1, nullptr), ARKUI_ERROR_CODE_NO_ERROR);
5357     nodeAPI->unregisterNodeCustomEvent(rootNode, ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE);
5358     nodeAPI->unregisterNodeCustomEvent(rootNode, ARKUI_NODE_CUSTOM_EVENT_ON_DRAW);
5359     nodeAPI->disposeNode(rootNode);
5360 }
5361 
5362 /**
5363  * @tc.name: NativeNodeTest081
5364  * @tc.desc: Test native style string.
5365  * @tc.type: FUNC
5366  */
5367 HWTEST_F(NativeNodeTest, NativeNodeTest081, TestSize.Level1)
5368 {
5369     OH_Drawing_TypographyStyle* style = OH_Drawing_CreateTypographyStyle();
5370     ArkUI_StyledString* styleString = OH_ArkUI_StyledString_Create(style, nullptr);
5371     OH_Drawing_TextStyle* textStyle = OH_Drawing_CreateTextStyle();
5372     OH_ArkUI_StyledString_PushTextStyle(styleString, textStyle);
5373     OH_Drawing_PlaceholderSpan* placeholder = new OH_Drawing_PlaceholderSpan();
5374     OH_ArkUI_StyledString_AddPlaceholder(styleString, placeholder);
5375 
5376     OH_Drawing_DestroyTextStyle(textStyle);
5377     delete placeholder;
5378     OH_ArkUI_StyledString_PushTextStyle(styleString, textStyle);
5379     OH_ArkUI_StyledString_AddPlaceholder(styleString, placeholder);
5380     EXPECT_NE(styleString, nullptr);
5381     EXPECT_NE(textStyle, nullptr);
5382     EXPECT_NE(placeholder, nullptr);
5383 }
5384 
5385 /**
5386  * @tc.name: NativeNodeTest082
5387  * @tc.desc: Test OH_ArkUI_NodeEvent_GetTextChangeEvent function.
5388  * @tc.type: FUNC
5389  */
5390 HWTEST_F(NativeNodeTest, NativeNodeTest082, TestSize.Level1)
5391 {
5392     ArkUI_NodeEvent event = { 0, 0 };
5393     event.origin = nullptr;
5394     const std::string str = "test";
5395     EXPECT_EQ(OH_ArkUI_NodeEvent_GetTextChangeEvent(nullptr), nullptr);
5396     EXPECT_EQ(OH_ArkUI_NodeEvent_GetTextChangeEvent(&event), nullptr);
5397     event.category = 2;
5398     EXPECT_EQ(OH_ArkUI_NodeEvent_GetTextChangeEvent(&event), nullptr);
5399     ArkUINodeEvent origin = { 0, 0, 0};
5400     origin.textChangeEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_CHANGE_WITH_PREVIEW_TEXT;
5401     origin.textChangeEvent.nativeStringPtr = const_cast<char*>(str.c_str());
5402     origin.textChangeEvent.extendStringPtr = const_cast<char*>(str.c_str());
5403     origin.textChangeEvent.numArgs = 0;
5404     event.origin = &origin;
5405     EXPECT_NE(OH_ArkUI_NodeEvent_GetTextChangeEvent(&event), nullptr);
5406 }
5407 
5408 /**
5409  * @tc.name: BackdropBlurTest
5410  * @tc.desc: Test customNode function.
5411  * @tc.type: FUNC
5412  */
5413 HWTEST_F(NativeNodeTest, BackdropBlurTest, TestSize.Level1)
5414 {
5415     /**
5416      * @tc.steps: step1. create nodeAPI、rootNode、childNode.
5417      */
5418     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5419         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5420     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
5421     ASSERT_NE(rootNode, nullptr);
5422 
5423     /**
5424      * @tc.steps: step2. init value.
5425      */
5426     float val0 = 0.0f;
5427     ArkUI_NumberValue value[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0}};
5428     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
5429 
5430     ArkUI_NumberValue value1[] = {{.f32 = val0}};
5431     ArkUI_AttributeItem item1 = {value1, sizeof(value1) / sizeof(ArkUI_NumberValue)};
5432 
5433     ArkUI_NumberValue value2[] = {{.f32 = val0}, {.f32 = val0}, {.f32 = val0}, {.f32 = val0}};
5434     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
5435     /**
5436      * @tc.steps: step3. test NODE_BACKDROP_BLUR ,when one values are in the legal range.
5437      */
5438     value1[0].f32 = 20;
5439     auto backdropBlurResult = nodeAPI->setAttribute(rootNode, NODE_BACKDROP_BLUR, &item1);
5440     EXPECT_EQ(backdropBlurResult, 0);
5441     auto backdropBlurVal = nodeAPI->getAttribute(rootNode, NODE_BACKDROP_BLUR);
5442     EXPECT_EQ(backdropBlurVal->value[0].f32, 20);
5443 
5444     /**
5445      * @tc.steps: step4. test NODE_BACKDROP_BLUR ,when three values are in the legal range.
5446      */
5447     value[0].f32 = 20;
5448     value[1].f32 = 30;
5449     value[2].f32 = 50;
5450 
5451     backdropBlurResult = nodeAPI->setAttribute(rootNode, NODE_BACKDROP_BLUR, &item);
5452     EXPECT_EQ(backdropBlurResult, 0);
5453     backdropBlurVal = nodeAPI->getAttribute(rootNode, NODE_BACKDROP_BLUR);
5454     EXPECT_EQ(backdropBlurVal->value[0].f32, 20);
5455     EXPECT_EQ(backdropBlurVal->value[1].f32, 30);
5456     EXPECT_EQ(backdropBlurVal->value[2].f32, 50);
5457 
5458     /**
5459      * @tc.steps: step5. test NODE_BACKDROP_BLUR ,when the first value is not in the legal range.
5460      */
5461     value[0].f32 = -20;
5462     value[1].f32 = 30;
5463     value[2].f32 = 50;
5464 
5465     backdropBlurResult = nodeAPI->setAttribute(rootNode, NODE_BACKDROP_BLUR, &item);
5466     EXPECT_EQ(backdropBlurResult, 401);
5467 
5468     /**
5469      * @tc.steps: step6. test NODE_BACKDROP_BLUR ,when the second value is not in the legal range.
5470      */
5471     value[0].f32 = 20;
5472     value[1].f32 = 128;
5473     value[2].f32 = 127;
5474 
5475     backdropBlurResult = nodeAPI->setAttribute(rootNode, NODE_BACKDROP_BLUR, &item);
5476     EXPECT_EQ(backdropBlurResult, 401);
5477 
5478     /**
5479      * @tc.steps: step7. test NODE_BACKDROP_BLUR ,when the third value is not in the legal range.
5480      */
5481     value[0].f32 = 20;
5482     value[1].f32 = 127;
5483     value[2].f32 = 128;
5484 
5485     backdropBlurResult = nodeAPI->setAttribute(rootNode, NODE_BACKDROP_BLUR, &item);
5486     EXPECT_EQ(backdropBlurResult, 401);
5487 
5488     /**
5489      * @tc.steps: step8. test NODE_BACKDROP_BLUR ,when four parameters are passed in.
5490      */
5491     value2[0].f32 = 20;
5492     value2[1].f32 = 127;
5493     value2[2].f32 = 127;
5494     value2[3].f32 = 127;
5495 
5496     backdropBlurResult = nodeAPI->setAttribute(rootNode, NODE_BACKDROP_BLUR, &item2);
5497     EXPECT_EQ(backdropBlurResult, 401);
5498 }
5499 
5500 /**
5501  * @tc.name: NativeNodeProgressTest001
5502  * @tc.desc: Test progressNode function.
5503  * @tc.type: FUNC
5504  */
5505 HWTEST_F(NativeNodeTest, NativeNodeProgressTest001, TestSize.Level1)
5506 {
5507     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5508         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5509     ASSERT_NE(nodeAPI, nullptr);
5510     auto rootNode = nodeAPI->createNode(ARKUI_NODE_PROGRESS);
5511     ASSERT_NE(rootNode, nullptr);
5512     ArkUI_NumberValue value[] = {{.f32 = 10.0f}};
5513     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
5514     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_VALUE, &item);
5515     value[0].i32 = 100.0f;
5516     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TOTAL, &item);
5517     value[0].i32 = ARKUI_PROGRESS_TYPE_LINEAR;
5518     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TYPE, &item);
5519 
5520     auto linearStyleOption = OH_ArkUI_ProgressLinearStyleOption_Create();
5521     ArkUI_AttributeItem linearStyleItem = {.size = 0, .object = linearStyleOption};
5522     OH_ArkUI_ProgressLinearStyleOption_SetSmoothEffectEnabled(linearStyleOption, false);
5523     OH_ArkUI_ProgressLinearStyleOption_SetScanEffectEnabled(linearStyleOption, true);
5524     OH_ArkUI_ProgressLinearStyleOption_SetStrokeWidth(linearStyleOption, 50.0f);
5525     OH_ArkUI_ProgressLinearStyleOption_SetStrokeRadius(linearStyleOption, 20.0f);
5526     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_LINEAR_STYLE, &linearStyleItem);
5527 
5528     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetSmoothEffectEnabled(linearStyleOption), false);
5529     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetScanEffectEnabled(linearStyleOption), true);
5530     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetStrokeWidth(linearStyleOption), 50.0f);
5531     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetStrokeRadius(linearStyleOption), 20.0f);
5532 
5533     nodeAPI->resetAttribute(rootNode, NODE_PROGRESS_LINEAR_STYLE);
5534     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetSmoothEffectEnabled(linearStyleOption), false);
5535     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetScanEffectEnabled(linearStyleOption), true);
5536     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetStrokeWidth(linearStyleOption), 50.0f);
5537     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetStrokeRadius(linearStyleOption), 20.0f);
5538     OH_ArkUI_ProgressLinearStyleOption_Destroy(linearStyleOption);
5539     nodeAPI->disposeNode(rootNode);
5540 }
5541 
5542 /**
5543  * @tc.name: NativeNodeProgressTest002
5544  * @tc.desc: Test progressNode function.
5545  * @tc.type: FUNC
5546  */
5547 HWTEST_F(NativeNodeTest, NativeNodeProgressTest002, TestSize.Level1)
5548 {
5549     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5550         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5551     ASSERT_NE(nodeAPI, nullptr);
5552     auto rootNode = nodeAPI->createNode(ARKUI_NODE_PROGRESS);
5553     ASSERT_NE(rootNode, nullptr);
5554     ArkUI_NumberValue value[] = {{.f32 = 10.0f}};
5555     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
5556     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_VALUE, &item);
5557     value[0].i32 = 100.0f;
5558     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TOTAL, &item);
5559     value[0].i32 = ARKUI_PROGRESS_TYPE_LINEAR;
5560     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TYPE, &item);
5561 
5562     ArkUI_ProgressLinearStyleOption* linearStyleOption = nullptr;
5563     // set attribute value
5564     OH_ArkUI_ProgressLinearStyleOption_SetSmoothEffectEnabled(linearStyleOption, false);
5565     OH_ArkUI_ProgressLinearStyleOption_SetScanEffectEnabled(linearStyleOption, true);
5566     OH_ArkUI_ProgressLinearStyleOption_SetStrokeWidth(linearStyleOption, 50.0f);
5567     OH_ArkUI_ProgressLinearStyleOption_SetStrokeRadius(linearStyleOption, 20.0f);
5568 
5569     // get attribute default value
5570     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetSmoothEffectEnabled(linearStyleOption), true);
5571     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetScanEffectEnabled(linearStyleOption), false);
5572     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetStrokeWidth(linearStyleOption), -1.0f);
5573     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetStrokeRadius(linearStyleOption), -1.0f);
5574     OH_ArkUI_ProgressLinearStyleOption_Destroy(linearStyleOption);
5575 
5576     // reset attribute value
5577     nodeAPI->resetAttribute(rootNode, NODE_PROGRESS_LINEAR_STYLE);
5578     auto linearStyleItem = nodeAPI->getAttribute(rootNode, NODE_PROGRESS_LINEAR_STYLE);
5579     linearStyleOption = reinterpret_cast<ArkUI_ProgressLinearStyleOption*>(linearStyleItem->object);
5580     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetSmoothEffectEnabled(linearStyleOption), true);
5581     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetScanEffectEnabled(linearStyleOption), false);
5582     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetStrokeWidth(linearStyleOption), 4.0f);
5583     EXPECT_EQ(OH_ArkUI_ProgressLinearStyleOption_GetStrokeRadius(linearStyleOption), 2.0f);
5584     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_LINEAR_STYLE, nullptr);
5585 
5586     value[0].i32 = ARKUI_PROGRESS_TYPE_RING;
5587     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TYPE, &item);
5588     nodeAPI->setAttribute(rootNode, NODE_PROGRESS_LINEAR_STYLE, linearStyleItem);
5589     nodeAPI->resetAttribute(rootNode, NODE_PROGRESS_LINEAR_STYLE);
5590     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_PROGRESS_LINEAR_STYLE), nullptr);
5591     nodeAPI->disposeNode(rootNode);
5592 }
5593 
5594 /**
5595  * @tc.name: NativeNodeIssueTest001
5596  * @tc.desc: Test customSpanNode function.
5597  * @tc.type: FUNC
5598  */
5599 HWTEST_F(NativeNodeTest, NativeNodeIssueTest001, TestSize.Level1)
5600 {
5601     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5602         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5603     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
__anon12f168940102(ArkUI_NodeEvent* event) 5604     auto ret = OHOS::Ace::NodeModel::AddNodeEventReceiver(node, [](ArkUI_NodeEvent* event) {
5605         auto node = OH_ArkUI_NodeEvent_GetNodeHandle(event);
5606         OHOS::Ace::NodeModel::DisposeNode(node);
5607     });
5608     EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
5609     ArkUI_NodeEvent event = { 0, 0 };
5610     event.node = node;
5611     OHOS::Ace::NodeModel::HandleNodeEvent(&event);
5612 }
5613 
5614 /**
5615  * @tc.name: NativeNodeTest084
5616  * @tc.desc: Test swiperNode function.
5617  * @tc.type: FUNC
5618  */
5619 HWTEST_F(NativeNodeTest, NativeNodeTest084, TestSize.Level1)
5620 {
5621     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5622         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5623     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SWIPER);
5624     ArkUI_NumberValue value[] = { { .i32 = 1 }, { .i32 = 1 } };
5625     ArkUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr };
5626 
5627     value[0].i32 = true;
5628     value[1].i32 = false;
5629     auto ret = nodeAPI->setAttribute(rootNode, NODE_SWIPER_AUTO_PLAY, &item);
5630     EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
5631     auto resultTtem = nodeAPI->getAttribute(rootNode, NODE_SWIPER_AUTO_PLAY);
5632     EXPECT_TRUE(resultTtem->value[0].i32);
5633     EXPECT_FALSE(resultTtem->value[1].i32);
5634     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_AUTO_PLAY), ARKUI_ERROR_CODE_NO_ERROR);
5635     resultTtem = nodeAPI->getAttribute(rootNode, NODE_SWIPER_AUTO_PLAY);
5636     EXPECT_FALSE(resultTtem->value[0].i32);
5637     EXPECT_TRUE(resultTtem->value[1].i32);
5638     nodeAPI->disposeNode(rootNode);
5639 }
5640 
LayoutCallback(void * userData)5641 void LayoutCallback(void* userData)
5642 {
5643 }
5644 
5645 /**
5646  * @tc.name: NativeNodeTest085
5647  * @tc.desc: Test OH_ArkUI_RegisterLayoutCallbackOnNodeHandle function.
5648  * @tc.type: FUNC
5649  */
5650 HWTEST_F(NativeNodeTest, NativeNodeTest085, TestSize.Level1)
5651 {
5652     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5653         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5654     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
5655     auto ret = OH_ArkUI_RegisterLayoutCallbackOnNodeHandle(node, nullptr, LayoutCallback);
5656     EXPECT_EQ(ret, ERROR_CODE_NO_ERROR);
5657     ret = OH_ArkUI_RegisterLayoutCallbackOnNodeHandle(nullptr, nullptr, LayoutCallback);
5658     EXPECT_EQ(ret, ERROR_CODE_PARAM_INVALID);
5659 }
5660 
5661 /**
5662  * @tc.name: NativeNodeTest086
5663  * @tc.desc: Test OH_ArkUI_RegisterDrawCallbackOnNodeHandle function.
5664  * @tc.type: FUNC
5665  */
5666 HWTEST_F(NativeNodeTest, NativeNodeTest086, TestSize.Level1)
5667 {
5668     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5669         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5670     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
5671     auto ret = OH_ArkUI_RegisterDrawCallbackOnNodeHandle(node, nullptr, LayoutCallback);
5672     EXPECT_EQ(ret, ERROR_CODE_NO_ERROR);
5673     ret = OH_ArkUI_RegisterDrawCallbackOnNodeHandle(nullptr, nullptr, LayoutCallback);
5674     EXPECT_EQ(ret, ERROR_CODE_PARAM_INVALID);
5675 }
5676 
5677 /**
5678  * @tc.name: NativeNodeTest087
5679  * @tc.desc: Test OH_ArkUI_UnregisterLayoutCallbackOnNodeHandle function.
5680  * @tc.type: FUNC
5681  */
5682 HWTEST_F(NativeNodeTest, NativeNodeTest087, TestSize.Level1)
5683 {
5684     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5685         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5686     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
5687     auto ret = OH_ArkUI_UnregisterLayoutCallbackOnNodeHandle(node);
5688     EXPECT_EQ(ret, ERROR_CODE_NO_ERROR);
5689     ret = OH_ArkUI_UnregisterLayoutCallbackOnNodeHandle(nullptr);
5690     EXPECT_EQ(ret, ERROR_CODE_PARAM_INVALID);
5691 }
5692 
5693 /**
5694  * @tc.name: NativeNodeTest088
5695  * @tc.desc: Test OH_ArkUI_UnregisterDrawCallbackOnNodeHandle function.
5696  * @tc.type: FUNC
5697  */
5698 HWTEST_F(NativeNodeTest, NativeNodeTest088, TestSize.Level1)
5699 {
5700     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5701         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5702     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
5703     auto ret = OH_ArkUI_UnregisterDrawCallbackOnNodeHandle(node);
5704     EXPECT_EQ(ret, ERROR_CODE_NO_ERROR);
5705     ret = OH_ArkUI_UnregisterDrawCallbackOnNodeHandle(nullptr);
5706     EXPECT_EQ(ret, ERROR_CODE_PARAM_INVALID);
5707 }
5708 
5709 /**
5710  * @tc.name: NativeNodeTest089
5711  * @tc.desc: Test xcomponentNode of TEXTURE type function.
5712  * @tc.type: FUNC
5713  */
5714 HWTEST_F(NativeNodeTest, NativeNodeTest089, TestSize.Level1)
5715 {
5716     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5717         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5718     auto rootNode = nodeAPI->createNode(ARKUI_NODE_XCOMPONENT_TEXTURE);
5719     ASSERT_NE(rootNode, nullptr);
5720 
5721     ArkUI_NumberValue value[] = {{.i32 = ARKUI_XCOMPONENT_TYPE_TEXTURE}, {.f32 = 10.0f}};
5722     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"};
5723     nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_ID, &item);
5724     nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item);
5725 
5726     uint32_t val100 = 100;
5727     value[0].u32 = val100;
5728     value[1].u32 = val100;
5729     nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_SURFACE_SIZE, &item);
5730 
5731     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_XCOMPONENT_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
5732     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_XCOMPONENT_SURFACE_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
5733 
5734     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_XCOMPONENT_ID), nullptr);
5735     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_XCOMPONENT_TYPE), nullptr);
5736     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_XCOMPONENT_SURFACE_SIZE), nullptr);
5737     nodeAPI->disposeNode(rootNode);
5738 }
5739 
5740 /**
5741  * @tc.name: NativeNodeTest090
5742  * @tc.desc: Test abnormalInput For XComponent of TEXTURE type function.
5743  * @tc.type: FUNC
5744  */
5745 HWTEST_F(NativeNodeTest, NativeNodeTest090, TestSize.Level1)
5746 {
5747     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5748         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5749     auto rootNode = nodeAPI->createNode(ARKUI_NODE_XCOMPONENT_TEXTURE);
5750     ArkUI_NumberValue value0[] = {};
5751     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
5752     ArkUI_NumberValue value[] = {{.i32 = -1}};
5753     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
5754     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_ID, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
5755     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_ID, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
5756     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
5757     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
5758     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_SURFACE_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
5759     nodeAPI->disposeNode(rootNode);
5760 }
5761 
5762 /**
5763  * @tc.name: NativeNodeTest091
5764  * @tc.desc: Test scrollToIndex and scrollToItemInGroup function.
5765  * @tc.type: FUNC
5766  */
5767 HWTEST_F(NativeNodeTest, NativeNodeTest091, TestSize.Level1)
5768 {
5769     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5770         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5771     auto list = nodeAPI->createNode(ARKUI_NODE_LIST);
5772     auto listItem = nodeAPI->createNode(ARKUI_NODE_LIST_ITEM);
5773     auto listItemGroup = nodeAPI->createNode(ARKUI_NODE_LIST_ITEM_GROUP);
5774     nodeAPI->addChild(listItemGroup, listItem);
5775     nodeAPI->addChild(list, listItemGroup);
5776     ASSERT_NE(list, nullptr);
5777     ArkUI_NumberValue value[] = { 0, 0, 0, 1 };
5778     ArkUI_AttributeItem item = { value, 4 };
5779     value[0].i32 = 0;
5780     value[1].i32 = 0;
5781     value[2].i32 = 0;
5782     value[3].i32 = 1;
5783     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_SCROLL_TO_INDEX, &item), ARKUI_ERROR_CODE_NO_ERROR);
5784     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_SCROLL_TO_INDEX_IN_GROUP, &item), ARKUI_ERROR_CODE_NO_ERROR);
5785     value[0].i32 = 2;
5786     value[1].i32 = 2;
5787     ArkUI_AttributeItem item0 = { value, 2 };
5788     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_SCROLL_TO_INDEX_IN_GROUP, &item0), ARKUI_ERROR_CODE_NO_ERROR);
5789     value[0].i32 = 3;
5790     value[1].i32 = 3;
5791     value[2].i32 = -1;
5792     value[3].i32 = -1;
5793     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_SCROLL_TO_INDEX_IN_GROUP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
5794     nodeAPI->disposeNode(listItem);
5795     nodeAPI->disposeNode(listItemGroup);
5796     nodeAPI->disposeNode(list);
5797 }
5798 
5799 /**
5800  * @tc.name: NativeNodeTest092
5801  * @tc.desc: Test setLanes function.
5802  * @tc.type: FUNC
5803  */
5804 HWTEST_F(NativeNodeTest, NativeNodeTest092, TestSize.Level1)
5805 {
5806     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5807         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5808     auto list = nodeAPI->createNode(ARKUI_NODE_LIST);
5809     ASSERT_NE(list, nullptr);
5810     ArkUI_NumberValue value[] = { 2, 3, 4, 5 };
5811     ArkUI_AttributeItem item = { value, 4 };
5812     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_LANES, &item), ARKUI_ERROR_CODE_NO_ERROR);
5813     auto ret = nodeAPI->getAttribute(list, NODE_LIST_LANES);
5814     EXPECT_EQ(ret->value[0].u32, 1);
5815     EXPECT_EQ(ret->value[1].f32, 3);
5816     EXPECT_EQ(ret->value[2].f32, 4);
5817     EXPECT_EQ(ret->value[3].f32, 5);
5818     value[0].u32 = 2;
5819     value[1].f32 = -1;
5820     value[2].f32 = -1;
5821     value[3].f32 = 3;
5822     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_LANES, &item), ARKUI_ERROR_CODE_NO_ERROR);
5823     ret = nodeAPI->getAttribute(list, NODE_LIST_LANES);
5824     EXPECT_EQ(ret->value[0].u32, 2);
5825     EXPECT_EQ(ret->value[1].f32, 0);
5826     EXPECT_EQ(ret->value[2].f32, 0);
5827     EXPECT_EQ(ret->value[3].f32, 3);
5828     EXPECT_EQ(nodeAPI->resetAttribute(list, NODE_LIST_LANES), ARKUI_ERROR_CODE_NO_ERROR);
5829     ret = nodeAPI->getAttribute(list, NODE_LIST_LANES);
5830     EXPECT_EQ(ret->value[0].u32, 1);
5831     EXPECT_EQ(ret->value[1].f32, 0);
5832     EXPECT_EQ(ret->value[2].f32, 0);
5833     EXPECT_EQ(ret->value[3].f32, 0);
5834     value[0].u32 = -1;
5835     value[1].f32 = -1;
5836     value[2].f32 = -1;
5837     value[3].f32 = -1;
5838     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_LANES, &item), ARKUI_ERROR_CODE_NO_ERROR);
5839     ret = nodeAPI->getAttribute(list, NODE_LIST_LANES);
5840     EXPECT_EQ(ret->value[0].u32, 1);
5841     EXPECT_EQ(ret->value[1].f32, 0);
5842     EXPECT_EQ(ret->value[2].f32, 0);
5843     EXPECT_EQ(ret->value[3].f32, 0);
5844     nodeAPI->disposeNode(list);
5845 }
5846 
5847 /**
5848  * @tc.name: NativeNodeTest093
5849  * @tc.desc: Test listScrollSnapAlign function.
5850  * @tc.type: FUNC
5851  */
5852 HWTEST_F(NativeNodeTest, NativeNodeTest093, TestSize.Level1)
5853 {
5854     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5855         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5856     auto list = nodeAPI->createNode(ARKUI_NODE_LIST);
5857     ASSERT_NE(list, nullptr);
5858     ArkUI_NumberValue value[] = { 1 };
5859     ArkUI_AttributeItem item = { value, 1 };
5860     value[0].i32 = 1;
5861     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_SCROLL_SNAP_ALIGN, &item), ARKUI_ERROR_CODE_NO_ERROR);
5862     auto ret = nodeAPI->getAttribute(list, NODE_LIST_SCROLL_SNAP_ALIGN);
5863     EXPECT_EQ(ret->value[0].i32, 1);
5864     EXPECT_EQ(nodeAPI->resetAttribute(list, NODE_LIST_SCROLL_SNAP_ALIGN), ARKUI_ERROR_CODE_NO_ERROR);
5865     ret = nodeAPI->getAttribute(list, NODE_LIST_SCROLL_SNAP_ALIGN);
5866     EXPECT_EQ(ret->value[0].i32, 0);
5867     value[0].i32 = -1;
5868     nodeAPI->setAttribute(list, NODE_LIST_SCROLL_SNAP_ALIGN, &item);
5869     ret = nodeAPI->getAttribute(list, NODE_LIST_SCROLL_SNAP_ALIGN);
5870     EXPECT_EQ(ret->value[0].i32, 0);
5871     nodeAPI->disposeNode(list);
5872 }
5873 
5874 /**
5875  * @tc.name: NativeNodeTest094
5876  * @tc.desc: Test scrollContentStartOffset and scrollContentEndOffset function.
5877  * @tc.type: FUNC
5878  */
5879 HWTEST_F(NativeNodeTest, NativeNodeTest094, TestSize.Level1)
5880 {
5881     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5882         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5883     auto list = nodeAPI->createNode(ARKUI_NODE_LIST);
5884     ASSERT_NE(list, nullptr);
5885     ArkUI_NumberValue value[] = { 1 };
5886     ArkUI_AttributeItem item = { value, 1 };
5887     value[0].f32 = 1;
5888     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_SCROLL_CONTENT_START_OFFSET, &item), ARKUI_ERROR_CODE_NO_ERROR);
5889     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_SCROLL_CONTENT_END_OFFSET, &item), ARKUI_ERROR_CODE_NO_ERROR);
5890     auto ret = nodeAPI->getAttribute(list, NODE_SCROLL_CONTENT_START_OFFSET);
5891     EXPECT_EQ(ret->value[0].f32, 1);
5892     ret = nodeAPI->getAttribute(list, NODE_SCROLL_CONTENT_END_OFFSET);
5893     EXPECT_EQ(ret->value[0].f32, 1);
5894     EXPECT_EQ(nodeAPI->resetAttribute(list, NODE_SCROLL_CONTENT_START_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
5895     EXPECT_EQ(nodeAPI->resetAttribute(list, NODE_SCROLL_CONTENT_END_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
5896     ret = nodeAPI->getAttribute(list, NODE_SCROLL_CONTENT_START_OFFSET);
5897     EXPECT_EQ(ret->value[0].f32, 0);
5898     ret = nodeAPI->getAttribute(list, NODE_SCROLL_CONTENT_END_OFFSET);
5899     EXPECT_EQ(ret->value[0].f32, 0);
5900     nodeAPI->disposeNode(list);
5901 }
5902 
5903 /**
5904  * @tc.name: NativeNodeTest095
5905  * @tc.desc: Test listMaintainVisibleContentPosition function.
5906  * @tc.type: FUNC
5907  */
5908 HWTEST_F(NativeNodeTest, NativeNodeTest095, TestSize.Level1)
5909 {
5910     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5911         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5912     auto list = nodeAPI->createNode(ARKUI_NODE_LIST);
5913     ASSERT_NE(list, nullptr);
5914     ArkUI_NumberValue value[] = { 1 };
5915     ArkUI_AttributeItem item = { value, 1 };
5916     value[0].i32 = 1;
5917     auto ret = nodeAPI->setAttribute(list, NODE_LIST_MAINTAIN_VISIBLE_CONTENT_POSITION, &item);
5918     EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
5919     auto ret1 = nodeAPI->getAttribute(list, NODE_LIST_MAINTAIN_VISIBLE_CONTENT_POSITION);
5920     EXPECT_EQ(ret1->value[0].i32, 1);
5921     EXPECT_EQ(nodeAPI->resetAttribute(list, NODE_LIST_MAINTAIN_VISIBLE_CONTENT_POSITION), ARKUI_ERROR_CODE_NO_ERROR);
5922     ret1 = nodeAPI->getAttribute(list, NODE_LIST_MAINTAIN_VISIBLE_CONTENT_POSITION);
5923     EXPECT_EQ(ret1->value[0].i32, 0);
5924     nodeAPI->disposeNode(list);
5925 }
5926 
5927 /**
5928  * @tc.name: NativeNodeTest096
5929  * @tc.desc: Test onScrollVisibleContentChange function.
5930  * @tc.type: FUNC
5931  */
5932 HWTEST_F(NativeNodeTest, NativeNodeTest096, TestSize.Level1)
5933 {
5934     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5935         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5936     auto listNode = nodeAPI->createNode(ARKUI_NODE_LIST);
5937     auto ret = nodeAPI->registerNodeEvent(listNode, NODE_LIST_ON_SCROLL_VISIBLE_CONTENT_CHANGE, 1, nullptr);
5938     EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
5939     nodeAPI->unregisterNodeEvent(listNode, NODE_LIST_ON_SCROLL_VISIBLE_CONTENT_CHANGE);
5940     nodeAPI->disposeNode(listNode);
5941 
5942     int32_t nodeType = static_cast<int32_t>(ARKUI_NODE_LIST);
5943     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_LIST_ON_SCROLL_VISIBLE_CONTENT_CHANGE, nodeType);
5944     EXPECT_EQ(ret, static_cast<int32_t>(ON_LIST_SCROLL_VISIBLE_CONTENT_CHANGE));
5945 
5946     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_LIST_SCROLL_VISIBLE_CONTENT_CHANGE);
5947     EXPECT_EQ(ret, static_cast<int32_t>(NODE_LIST_ON_SCROLL_VISIBLE_CONTENT_CHANGE));
5948 }
5949 
5950 /**
5951  * @tc.name: NativeNodeTest097
5952  * @tc.desc: Test cachedCount function.
5953  * @tc.type: FUNC
5954  */
5955 HWTEST_F(NativeNodeTest, NativeNodeTest097, TestSize.Level1)
5956 {
5957     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5958         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5959     auto list = nodeAPI->createNode(ARKUI_NODE_LIST);
5960     ASSERT_NE(list, nullptr);
5961     ArkUI_NumberValue value[] = { 1, 1 };
5962     ArkUI_AttributeItem item = { value, 2 };
5963     value[0].i32 = 1;
5964     value[1].i32 = 1;
5965     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_CACHED_COUNT, &item), ARKUI_ERROR_CODE_NO_ERROR);
5966     auto ret = nodeAPI->getAttribute(list, NODE_LIST_CACHED_COUNT);
5967     EXPECT_EQ(ret->value[1].i32, 1);
5968     EXPECT_EQ(nodeAPI->resetAttribute(list, NODE_LIST_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
5969     ret = nodeAPI->getAttribute(list, NODE_LIST_CACHED_COUNT);
5970     EXPECT_EQ(ret->value[1].i32, 0);
5971     value[1].i32 = -1;
5972     EXPECT_EQ(nodeAPI->setAttribute(list, NODE_LIST_CACHED_COUNT, &item), ARKUI_ERROR_CODE_NO_ERROR);
5973     ret = nodeAPI->getAttribute(list, NODE_LIST_CACHED_COUNT);
5974     EXPECT_EQ(ret->value[1].i32, 0);
5975     nodeAPI->disposeNode(list);
5976 }
5977 
5978 /**
5979  * @tc.name: NativeNodeTest098
5980  * @tc.desc: Test setHeader and setFooter function.
5981  * @tc.type: FUNC
5982  */
5983 HWTEST_F(NativeNodeTest, NativeNodeTest098, TestSize.Level1)
5984 {
5985     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5986         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5987     auto listItemGroup = nodeAPI->createNode(ARKUI_NODE_LIST_ITEM_GROUP);
5988     ASSERT_NE(listItemGroup, nullptr);
5989     EXPECT_EQ(nodeAPI->resetAttribute(listItemGroup, NODE_LIST_ITEM_GROUP_SET_HEADER), ARKUI_ERROR_CODE_NO_ERROR);
5990     EXPECT_EQ(nodeAPI->resetAttribute(listItemGroup, NODE_LIST_ITEM_GROUP_SET_FOOTER), ARKUI_ERROR_CODE_NO_ERROR);
5991     nodeAPI->disposeNode(listItemGroup);
5992 }
5993 
5994 /**
5995  * @tc.name: NativeNodeTest099
5996  * @tc.desc: Test LazyForEach function.
5997  * @tc.type: FUNC
5998  */
5999 HWTEST_F(NativeNodeTest, NativeNodeTest099, TestSize.Level1)
6000 {
6001     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
6002         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
6003     auto listItemGroup = nodeAPI->createNode(ARKUI_NODE_LIST_ITEM_GROUP);
6004     ASSERT_NE(listItemGroup, nullptr);
6005     ArkUI_NumberValue value0[] = {};
6006     ArkUI_AttributeItem item0 = { value0, 0, nullptr, nullptr };
6007     auto ret = nodeAPI->setAttribute(listItemGroup, NODE_LIST_ITEM_GROUP_NODE_ADAPTER, &item0);
6008     EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
6009     EXPECT_EQ(nodeAPI->resetAttribute(listItemGroup, NODE_LIST_ITEM_GROUP_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
6010     EXPECT_NE(nodeAPI->getAttribute(listItemGroup, NODE_LIST_ITEM_GROUP_NODE_ADAPTER), nullptr);
6011     nodeAPI->disposeNode(listItemGroup);
6012 }
6013 
6014 /**
6015  * @tc.name: NativeNodeTest097
6016  * @tc.desc: Test SetOnVisibleAreaApproximateChange function.
6017  * @tc.type: FUNC
6018  */
6019 HWTEST_F(NativeNodeTest, NativeNodeTest100, TestSize.Level1)
6020 {
6021     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
6022         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
6023     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
6024     auto option = OH_ArkUI_VisibleAreaEventOptions_Create();
6025     float* ratiosArray = new float[2];
6026     ratiosArray[0] = 0.0f;
6027     ratiosArray[1] = 1.0f;
6028     OH_ArkUI_VisibleAreaEventOptions_SetRatios(option, ratiosArray, 2);
6029     ArkUI_AttributeItem attributeItem = { .object = option };
6030     nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_APPROXIMATE_CHANGE_RATIO, &attributeItem);
6031     auto ret = nodeAPI->registerNodeEvent(rootNode, NODE_VISIBLE_AREA_APPROXIMATE_CHANGE_EVENT, 1, nullptr);
6032     EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
6033     nodeAPI->unregisterNodeEvent(rootNode, NODE_VISIBLE_AREA_APPROXIMATE_CHANGE_EVENT);
6034     nodeAPI->disposeNode(rootNode);
6035 
6036     int32_t nodeType = static_cast<int32_t>(ARKUI_NODE_BUTTON);
6037     ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_VISIBLE_AREA_APPROXIMATE_CHANGE_EVENT, nodeType);
6038     EXPECT_EQ(ret, static_cast<int32_t>(ON_VISIBLE_AREA_APPROXIMATE_CHANGE));
6039 
6040     ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_VISIBLE_AREA_APPROXIMATE_CHANGE);
6041     EXPECT_EQ(ret, static_cast<int32_t>(NODE_VISIBLE_AREA_APPROXIMATE_CHANGE_EVENT));
6042 }
6043 
6044 /**
6045  * @tc.name: NativeNodeTest098
6046  * @tc.desc: Test NODE_VISIBLE_AREA_APPROXIMATE_CHANGE_RATIO.
6047  * @tc.type: FUNC
6048  */
6049 HWTEST_F(NativeNodeTest, NativeNodeTest101, TestSize.Level1)
6050 {
6051     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
6052         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
6053     ASSERT_NE(nodeAPI, nullptr);
6054     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
6055     ASSERT_NE(rootNode, nullptr);
6056 
6057     auto option = OH_ArkUI_VisibleAreaEventOptions_Create();
6058     float* ratiosArray = new float[2];
6059     ratiosArray[0] = 0.0f;
6060     ratiosArray[1] = 1.0f;
6061     OH_ArkUI_VisibleAreaEventOptions_SetRatios(option, ratiosArray, 2);
6062     OH_ArkUI_VisibleAreaEventOptions_SetExpectedUpdateInterval(option, 1000);
6063     ArkUI_AttributeItem attributeItem = { .object = option };
6064     nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_APPROXIMATE_CHANGE_RATIO, &attributeItem);
6065 
6066     float* getRatiosArray = new float[3];
6067     int size = 3;
6068     OH_ArkUI_VisibleAreaEventOptions_GetRatios(option, getRatiosArray, &size);
6069 
6070     EXPECT_EQ(getRatiosArray[0], 0.0f);
6071     EXPECT_EQ(getRatiosArray[1], 1.0f);
6072 
6073     EXPECT_EQ(OH_ArkUI_VisibleAreaEventOptions_GetExpectedUpdateInterval(option), 1000);
6074     nodeAPI->disposeNode(rootNode);
6075 }
6076 
6077 /**
6078  * @tc.name: NativeNodeTest102
6079  * @tc.desc: Test NODE_SWIPER_CACHED_COUNT function.
6080  * @tc.type: FUNC
6081  */
6082 HWTEST_F(NativeNodeTest, NativeNodeTest102, TestSize.Level1)
6083 {
6084     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
6085         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
6086     auto swiper = nodeAPI->createNode(ARKUI_NODE_SWIPER);
6087     ASSERT_NE(swiper, nullptr);
6088     ArkUI_NumberValue value[] = { 1, 1 };
6089     ArkUI_AttributeItem item = { value, 2 };
6090     value[0].i32 = 1;
6091     value[1].i32 = 1;
6092     EXPECT_EQ(nodeAPI->setAttribute(swiper, NODE_SWIPER_CACHED_COUNT, &item), ARKUI_ERROR_CODE_NO_ERROR);
6093     auto ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_CACHED_COUNT);
6094     EXPECT_EQ(ret->value[1].i32, 1);
6095     EXPECT_EQ(nodeAPI->resetAttribute(swiper, NODE_SWIPER_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
6096     ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_CACHED_COUNT);
6097     EXPECT_EQ(ret->value[1].i32, 0);
6098     value[1].i32 = -1;
6099     EXPECT_EQ(nodeAPI->setAttribute(swiper, NODE_SWIPER_CACHED_COUNT, &item), ARKUI_ERROR_CODE_NO_ERROR);
6100     ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_CACHED_COUNT);
6101     EXPECT_EQ(ret->value[1].i32, 0);
6102     nodeAPI->disposeNode(swiper);
6103 }
6104 
6105 /**
6106  * @tc.name: NativeNodeTest103
6107  * @tc.desc: Test NODE_SWIPER_AUTO_FILL function.
6108  * @tc.type: FUNC
6109  */
6110 HWTEST_F(NativeNodeTest, NativeNodeTest103, TestSize.Level1)
6111 {
6112     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
6113         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
6114     auto swiper = nodeAPI->createNode(ARKUI_NODE_SWIPER);
6115     ASSERT_NE(swiper, nullptr);
6116     ArkUI_NumberValue value[] = { 1, 1 };
6117     ArkUI_AttributeItem item = { value, 2 };
6118     value[0].f32 = 1;
6119     value[1].i32 = 1;
6120     EXPECT_EQ(nodeAPI->setAttribute(swiper, NODE_SWIPER_AUTO_FILL, &item), ARKUI_ERROR_CODE_NO_ERROR);
6121     auto ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_AUTO_FILL);
6122     EXPECT_EQ(ret->value[0].f32, 1);
6123     EXPECT_EQ(ret->value[1].i32, 1);
6124     EXPECT_EQ(nodeAPI->resetAttribute(swiper, NODE_SWIPER_AUTO_FILL), ARKUI_ERROR_CODE_NO_ERROR);
6125     ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_AUTO_FILL);
6126     EXPECT_EQ(ret->value[0].f32, 0);
6127     EXPECT_EQ(ret->value[1].i32, 0);
6128     value[0].f32 = -1;
6129     value[1].i32 = -1;
6130     EXPECT_EQ(nodeAPI->setAttribute(swiper, NODE_SWIPER_AUTO_FILL, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
6131     ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_AUTO_FILL);
6132     EXPECT_EQ(ret->value[0].f32, 0);
6133     EXPECT_EQ(ret->value[1].i32, 0);
6134     nodeAPI->disposeNode(swiper);
6135 }
6136 
6137 /**
6138  * @tc.name: NativeNodeTest104
6139  * @tc.desc: Test NODE_SWIPER_DISPLAY_COUNT function.
6140  * @tc.type: FUNC
6141  */
6142 HWTEST_F(NativeNodeTest, NativeNodeTest104, TestSize.Level1)
6143 {
6144     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
6145         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
6146     auto swiper = nodeAPI->createNode(ARKUI_NODE_SWIPER);
6147     ASSERT_NE(swiper, nullptr);
6148     ArkUI_NumberValue value[] = { {.i32 = 1}, {.i32 = 1} };
6149     ArkUI_AttributeItem item = { .value = value, .string = "auto", .size = 2};
6150     value[0].i32 = 1;
6151     value[1].i32 = 1;
6152     EXPECT_EQ(nodeAPI->setAttribute(swiper, NODE_SWIPER_DISPLAY_COUNT, &item), ARKUI_ERROR_CODE_NO_ERROR);
6153     auto ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_DISPLAY_COUNT);
6154     EXPECT_EQ(ret->value[0].i32, 1);
6155     EXPECT_EQ(ret->value[1].i32, 1);
6156     std::string str = "auto";
6157     EXPECT_EQ(ret->string, str);
6158     EXPECT_EQ(nodeAPI->resetAttribute(swiper, NODE_SWIPER_DISPLAY_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
6159     ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_DISPLAY_COUNT);
6160     EXPECT_EQ(ret->value[0].i32, 1);
6161     EXPECT_EQ(ret->value[1].i32, 0);
6162     value[0].i32 = -1;
6163     value[1].i32 = -1;
6164     nodeAPI->setAttribute(swiper, NODE_SWIPER_DISPLAY_COUNT, &item);
6165     ret = nodeAPI->getAttribute(swiper, NODE_SWIPER_DISPLAY_COUNT);
6166     EXPECT_EQ(ret->value[0].i32, 1);
6167     EXPECT_EQ(ret->value[1].i32, 0);
6168     nodeAPI->disposeNode(swiper);
6169 }
6170 
6171 /**
6172  * @tc.name: NativeNodeTest105
6173  * @tc.desc: Test NODE_SWIPER_SHOW_DISPLAY_ARROW function.
6174  * @tc.type: FUNC
6175  */
6176 HWTEST_F(NativeNodeTest, NativeNodeTest105, TestSize.Level1)
6177 {
6178     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
6179         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
6180     ArkUI_NodeHandle swiper = nodeAPI->createNode(ARKUI_NODE_SWIPER);
6181     const int size = 14;
6182     const char* arr[size] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"};
6183 
6184     for (int j = 0; j < size; j++) {
6185         ArkUI_NodeHandle textNode = nodeAPI->createNode(ARKUI_NODE_TEXT);
6186         ArkUI_AttributeItem content = { .string = arr[j] };
6187         nodeAPI->setAttribute(textNode, NODE_TEXT_CONTENT, &content);
6188 
6189         ArkUI_NumberValue value[] = {0};
6190         ArkUI_AttributeItem item = {value, 1};
6191         value[0].f32 = 400;
6192         nodeAPI->setAttribute(textNode, NODE_WIDTH, &item);
6193         value[0].f32 = 160;
6194         nodeAPI->setAttribute(textNode, NODE_HEIGHT, &item);
6195         value[0].u32 = 0xFFAFEEEE;
6196         nodeAPI->setAttribute(textNode, NODE_BACKGROUND_COLOR, &item);
6197         value[0].i32 = 0;
6198         nodeAPI->setAttribute(textNode, NODE_TEXT_ALIGN, &item);
6199         value[0].f32 = 30;
6200         nodeAPI->setAttribute(textNode, NODE_FONT_SIZE, &item);
6201 
6202         ArkUI_AttributeItem textId = {.string = "SwiperAutoPlayText"};
6203         nodeAPI->setAttribute(textNode, NODE_ID, &textId);
6204         nodeAPI->addChild(swiper, textNode);
6205     }
6206     ArkUI_SwiperArrowStyle* arrowStyle = OH_ArkUI_SwiperArrowStyle_Create();
6207     OH_ArkUI_SwiperArrowStyle_SetShowBackground(arrowStyle, 1);
6208     OH_ArkUI_SwiperArrowStyle_SetShowSidebarMiddle(arrowStyle, 0);
6209     OH_ArkUI_SwiperArrowStyle_SetBackgroundSize(arrowStyle, 25);
6210     OH_ArkUI_SwiperArrowStyle_SetBackgroundColor(arrowStyle, 0xFF182431);
6211     OH_ArkUI_SwiperArrowStyle_SetArrowSize(arrowStyle, 25);
6212     OH_ArkUI_SwiperArrowStyle_SetArrowColor(arrowStyle, 0xFF182431);
6213 
6214     ArkUI_NumberValue valueTemp[1];
6215     ArkUI_AttributeItem itemTemp = {.value=valueTemp, .size=1, .object = arrowStyle};
6216     valueTemp[0].i32 = 2;
6217     nodeAPI->setAttribute(swiper, NODE_SWIPER_SHOW_DISPLAY_ARROW, &itemTemp);
6218     auto itemTempReturn = nodeAPI->getAttribute(swiper, NODE_SWIPER_SHOW_DISPLAY_ARROW);
6219     auto returnObject = static_cast<ArkUI_SwiperArrowStyle*>(itemTempReturn->object);
6220     ASSERT_NE(returnObject, nullptr);
6221     EXPECT_EQ(OH_ArkUI_SwiperArrowStyle_GetShowBackground(arrowStyle), 1);
6222     EXPECT_EQ(OH_ArkUI_SwiperArrowStyle_GetShowSidebarMiddle(arrowStyle), 0);
6223     EXPECT_EQ(OH_ArkUI_SwiperArrowStyle_GetBackgroundSize(arrowStyle), 25);
6224     EXPECT_EQ(OH_ArkUI_SwiperArrowStyle_GetBackgroundColor(arrowStyle), 0xFF182431);
6225     EXPECT_EQ(OH_ArkUI_SwiperArrowStyle_GetArrowSize(arrowStyle), 18.75);
6226     EXPECT_EQ(OH_ArkUI_SwiperArrowStyle_GetArrowColor(arrowStyle), 0xFF182431);
6227     OH_ArkUI_SwiperArrowStyle_Destroy(arrowStyle);
6228     nodeAPI->disposeNode(swiper);
6229 }
6230 
6231 /**
6232  * @tc.name: NativeNodeTest106
6233  * @tc.desc: Test NODE_BACKGROUND_IMAGE_RESIZABLE_WITH_SLICE function.
6234  * @tc.type: FUNC
6235  */
6236 HWTEST_F(NativeNodeTest, NativeNodeTest106, TestSize.Level1)
6237 {
6238     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
6239         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
6240     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
6241     auto childNode = nodeAPI->createNode(ARKUI_NODE_STACK);
6242     ASSERT_NE(rootNode, nullptr);
6243     int32_t ret1 = nodeAPI->addChild(rootNode, childNode);
6244     EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR);
6245     float size = 100.0f;
6246     float left = 6.0f;
6247     float top = 7.0f;
6248     float right  = 8.0f;
6249     float bottom = 9.0f;
6250     ArkUI_NumberValue value[] = {{.f32 = size}};
6251     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
6252 
6253     ArkUI_NumberValue value2[] = {{.f32 = left}, {.f32 = top}, {.f32 = right}, {.f32 = bottom}};
6254     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
6255 
6256     nodeAPI->setAttribute(rootNode, NODE_WIDTH, &item);
6257     auto widthVal = nodeAPI->getAttribute(rootNode, NODE_WIDTH);
6258     EXPECT_EQ(widthVal->value[0].f32, size);
6259 
6260     nodeAPI->setAttribute(rootNode, NODE_HEIGHT, &item);
6261     auto heightVal = nodeAPI->getAttribute(rootNode, NODE_HEIGHT);
6262     EXPECT_EQ(heightVal->value[0].f32, size);
6263 
6264     nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_RESIZABLE_WITH_SLICE, &item2);
6265     auto sliceVal = nodeAPI->getAttribute(rootNode, NODE_BACKGROUND_IMAGE_RESIZABLE_WITH_SLICE);
6266     EXPECT_EQ(sliceVal->value[0].f32, left);
6267     EXPECT_EQ(sliceVal->value[1].f32, top);
6268     EXPECT_EQ(sliceVal->value[2].f32, right);
6269     EXPECT_EQ(sliceVal->value[3].f32, bottom);
6270 }
6271 } // namespace OHOS::Ace