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