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